/*
 * Copyright Codeplay Software Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use these files except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// DO NOT MODIFY BY HAND
// This file was automatically generated by generate_conv2d_tests.py.
// Results calculated using Tensorflow v1.12.0.

#include <gtest/gtest.h>

#include "sycldnn/padding_mode.h"

#include "test/types/cartesian_product.h"
#include "test/types/kernel_data_types.h"
#include "test/types/nested_pairs_to_triple.h"
#include "test/types/test_backend_types.h"
#include "test/types/to_gtest_types.h"

#include "test/conv2d/selector_list.h"
#include "test/conv2d/window_stride_fixture.h"

#include <array>
#include <vector>

using DataTypeList = sycldnn::types::KernelDataTypes;
using Selectors = sycldnn::types::SelectorList;
using Backends = sycldnn::types::AllBackendTypes;

using SNNTypePairs =
    sycldnn::types::CartesianProduct<Selectors, DataTypeList>::type;
using BackendTypePairs =
    sycldnn::types::CartesianProduct<SNNTypePairs, Backends>::type;
using TestTriples = sycldnn::types::NestedPairsToTriple<BackendTypePairs>::type;

using GTestTypeTriples = sycldnn::types::ToGTestTypes<TestTriples>::type;

template <typename Pair>
using ForwardWindow3Stride1 = WindowStrideTest<Pair, 3, 1>;
TYPED_TEST_SUITE(ForwardWindow3Stride1, GTestTypeTriples);
TYPED_TEST(ForwardWindow3Stride1, SAME1x4x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {111., 178., 217., 145., 231., 348.,
                                         393., 252., 363., 528., 573., 360.,
                                         197., 274., 295., 175.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x4x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {348., 393., 528., 573.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x4x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      208., 222., 332., 356., 404., 434., 268., 290., 429.,  462.,  642.,
      696., 723., 786., 459., 504., 669., 726., 966., 1056., 1047., 1146.,
      651., 720., 348., 394., 476., 548., 512., 590., 296.,  350.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x4x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {642., 696.,  723.,  786.,
                                         966., 1056., 1047., 1146.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x4x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      402.,  416.,  430.,  444.,  640.,  664.,  688.,  712.,  778.,  808.,
      838.,  868.,  514.,  536.,  558.,  580.,  825.,  858.,  891.,  924.,
      1230., 1284., 1338., 1392., 1383., 1446., 1509., 1572., 873.,  918.,
      963.,  1008., 1281., 1338., 1395., 1452., 1842., 1932., 2022., 2112.,
      1995., 2094., 2193., 2292., 1233., 1302., 1371., 1440., 650.,  696.,
      742.,  788.,  880.,  952.,  1024., 1096., 946.,  1024., 1102., 1180.,
      538.,  592.,  646.,  700.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x4x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1230., 1284., 1338., 1392., 1383., 1446., 1509., 1572.,
      1842., 1932., 2022., 2112., 1995., 2094., 2193., 2292.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x4x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      808.,  1304., 1604., 1072., 1722., 2595., 2937., 1878.,
      2730., 3963., 4305., 2694., 1456., 2012., 2168., 1272.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x4x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2595., 2937., 3963., 4305.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x4x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1564., 1616., 2518., 2608., 3094., 3208., 2060., 2144.,
      3318., 3444., 4983., 5190., 5631., 5874., 3582., 3756.,
      5238., 5460., 7575., 7926., 8223., 8610., 5118., 5388.,
      2732., 2912., 3742., 4024., 4030., 4336., 2332., 2544.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x4x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {4983., 5190., 5631., 5874.,
                                         7575., 7926., 8223., 8610.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x4x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3076.,  3128.,  3180.,  3232.,  4946.,  5036.,  5126.,  5216.,
      6074.,  6188.,  6302.,  6416.,  4036.,  4120.,  4204.,  4288.,
      6510.,  6636.,  6762.,  6888.,  9759.,  9966.,  10173., 10380.,
      11019., 11262., 11505., 11748., 6990.,  7164.,  7338.,  7512.,
      10254., 10476., 10698., 10920., 14799., 15150., 15501., 15852.,
      16059., 16446., 16833., 17220., 9966.,  10236., 10506., 10776.,
      5284.,  5464.,  5644.,  5824.,  7202.,  7484.,  7766.,  8048.,
      7754.,  8060.,  8366.,  8672.,  4452.,  4664.,  4876.,  5088.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x4x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      9759.,  9966.,  10173., 10380., 11019., 11262., 11505., 11748.,
      14799., 15150., 15501., 15852., 16059., 16446., 16833., 17220.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x4x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6152.,  9964.,  12316., 8232.,  13284., 20022., 22686., 14484.,
      21156., 30678., 33342., 20820., 11176., 15388., 16588., 9672.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x4x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {20022., 22686., 30678., 33342.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x4x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      12104., 12304., 19580., 19928., 24188., 24632., 16136., 16464.,
      26076., 26568., 39234., 40044., 44418., 45372., 28284., 28968.,
      41436., 42312., 59970., 61356., 65154., 66684., 40572., 41640.,
      21640., 22352., 29660., 30776., 31964., 33176., 18504., 19344.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x4x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {39234., 40044., 44418., 45372.,
                                         59970., 61356., 65154., 66684.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x4x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      24008.,  24208.,  24408.,  24608.,  38812.,  39160.,  39508.,  39856.,
      47932.,  48376.,  48820.,  49264.,  31944.,  32272.,  32600.,  32928.,
      51660.,  52152.,  52644.,  53136.,  77658.,  78468.,  79278.,  80088.,
      87882.,  88836.,  89790.,  90744.,  55884.,  56568.,  57252.,  57936.,
      81996.,  82872.,  83748.,  84624.,  118554., 119940., 121326., 122712.,
      128778., 130308., 131838., 133368., 80076.,  81144.,  82212.,  83280.,
      42568.,  43280.,  43992.,  44704.,  58204.,  59320.,  60436.,  61552.,
      62716.,  63928.,  65140.,  66352.,  36168.,  37008.,  37848.,  38688.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x4x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      77658.,  78468.,  79278.,  80088.,  87882.,  88836.,  89790.,  90744.,
      118554., 119940., 121326., 122712., 128778., 130308., 131838., 133368.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x4x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      128., 202., 241., 280., 184., 276., 411., 456., 501., 318.,
      441., 636., 681., 726., 453., 240., 331., 352., 373., 220.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x4x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {411., 456., 501., 636., 681., 726.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x4x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      240., 256., 377.,  404.,  449.,  482.,  521.,  560.,  340., 368.,
      513., 552., 759.,  822.,  840.,  912.,  921.,  1002., 579., 636.,
      813., 882., 1164., 1272., 1245., 1362., 1326., 1452., 819., 906.,
      424., 480., 575.,  662.,  611.,  704.,  647.,  746.,  372., 440.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x4x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {759.,  822.,  840.,  912.,
                                         921.,  1002., 1164., 1272.,
                                         1245., 1362., 1326., 1452.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x4x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      464.,  480.,  496.,  512.,  727.,  754.,  781.,  808.,  865.,  898.,
      931.,  964.,  1003., 1042., 1081., 1120., 652.,  680.,  708.,  736.,
      987.,  1026., 1065., 1104., 1455., 1518., 1581., 1644., 1608., 1680.,
      1752., 1824., 1761., 1842., 1923., 2004., 1101., 1158., 1215., 1272.,
      1557., 1626., 1695., 1764., 2220., 2328., 2436., 2544., 2373., 2490.,
      2607., 2724., 2526., 2652., 2778., 2904., 1551., 1638., 1725., 1812.,
      792.,  848.,  904.,  960.,  1063., 1150., 1237., 1324., 1129., 1222.,
      1315., 1408., 1195., 1294., 1393., 1492., 676.,  744.,  812.,  880.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x4x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1455., 1518., 1581., 1644., 1608., 1680., 1752., 1824.,
      1761., 1842., 1923., 2004., 2220., 2328., 2436., 2544.,
      2373., 2490., 2607., 2724., 2526., 2652., 2778., 2904.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x4x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      940.,  1490., 1790., 2090., 1372., 2070., 3081., 3423., 3765., 2382.,
      3330., 4791., 5133., 5475., 3402., 1780., 2438., 2594., 2750., 1604.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x4x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {3081., 3423., 3765.,
                                         4791., 5133., 5475.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x4x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1820., 1880., 2878., 2980., 3454., 3580.,  4030.,  4180.,  2636., 2744.,
      3990., 4140., 5919., 6162., 6567., 6846.,  7215.,  7530.,  4542., 4764.,
      6390., 6660., 9159., 9582., 9807., 10266., 10455., 10950., 6462., 6804.,
      3340., 3560., 4534., 4876., 4822., 5188.,  5110.,  5500.,  2940., 3208.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x4x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5919., 6162.,  6567.,  6846.,
                                         7215., 7530.,  9159.,  9582.,
                                         9807., 10266., 10455., 10950.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x4x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3580.,  3640.,  3700.,  3760.,  5654.,  5756.,  5858.,  5960.,  6782.,
      6908.,  7034.,  7160.,  7910.,  8060.,  8210.,  8360.,  5164.,  5272.,
      5380.,  5488.,  7830.,  7980.,  8130.,  8280.,  11595., 11838., 12081.,
      12324., 12855., 13134., 13413., 13692., 14115., 14430., 14745., 15060.,
      8862.,  9084.,  9306.,  9528.,  12510., 12780., 13050., 13320., 17895.,
      18318., 18741., 19164., 19155., 19614., 20073., 20532., 20415., 20910.,
      21405., 21900., 12582., 12924., 13266., 13608., 6460.,  6680.,  6900.,
      7120.,  8726.,  9068.,  9410.,  9752.,  9278.,  9644.,  10010., 10376.,
      9830.,  10220., 10610., 11000., 5612.,  5880.,  6148.,  6416.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x4x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11595., 11838., 12081., 12324., 12855., 13134., 13413., 13692.,
      14115., 14430., 14745., 15060., 17895., 18318., 18741., 19164.,
      19155., 19614., 20073., 20532., 20415., 20910., 21405., 21900.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x4x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7192.,  11428., 13780., 16132., 10584., 16020., 23838.,
      26502., 29166., 18420., 25860., 37158., 39822., 42486.,
      26340., 13688., 18676., 19876., 21076., 12216.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x4x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {23838., 26502., 29166.,
                                         37158., 39822., 42486.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x4x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      14152., 14384., 22460., 22856., 27068., 27560., 31676., 32264.,
      20744., 21168., 31452., 32040., 46722., 47676., 51906., 53004.,
      57090., 58332., 35964., 36840., 50652., 51720., 72642., 74316.,
      77826., 79644., 83010., 84972., 51324., 52680., 26504., 27376.,
      35996., 37352., 38300., 39752., 40604., 42152., 23368., 24432.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x4x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {46722., 47676., 51906., 53004.,
                                         57090., 58332., 72642., 74316.,
                                         77826., 79644., 83010., 84972.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x4x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      28072.,  28304.,  28536.,  28768.,  44524.,  44920.,  45316.,  45712.,
      53644.,  54136.,  54628.,  55120.,  62764.,  63352.,  63940.,  64528.,
      41064.,  41488.,  41912.,  42336.,  62316.,  62904.,  63492.,  64080.,
      92490.,  93444.,  94398.,  95352.,  102714., 103812., 104910., 106008.,
      112938., 114180., 115422., 116664., 71052.,  71928.,  72804.,  73680.,
      100236., 101304., 102372., 103440., 143610., 145284., 146958., 148632.,
      153834., 155652., 157470., 159288., 164058., 166020., 167982., 169944.,
      101292., 102648., 104004., 105360., 52136.,  53008.,  53880.,  54752.,
      70636.,  71992.,  73348.,  74704.,  75148.,  76600.,  78052.,  79504.,
      79660.,  81208.,  82756.,  84304.,  45672.,  46736.,  47800.,  48864.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x4x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      92490.,  93444.,  94398.,  95352.,  102714., 103812., 104910., 106008.,
      112938., 114180., 115422., 116664., 143610., 145284., 146958., 148632.,
      153834., 155652., 157470., 159288., 164058., 166020., 167982., 169944.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x4x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      145., 226., 265., 304., 343., 223., 321., 474., 519., 564., 609., 384.,
      519., 744., 789., 834., 879., 546., 283., 388., 409., 430., 451., 265.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x4x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {474., 519., 564., 609.,
                                         744., 789., 834., 879.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x4x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      272.,  290.,  422.,  452.,  494., 530.,  566.,  608.,  638.,  686.,
      412.,  446.,  597.,  642.,  876., 948.,  957.,  1038., 1038., 1128.,
      1119., 1218., 699.,  768.,  957., 1038., 1362., 1488., 1443., 1578.,
      1524., 1668., 1605., 1758., 987., 1092., 500.,  566.,  674.,  776.,
      710.,  818.,  746.,  860.,  782., 902.,  448.,  530.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x4x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      876.,  948.,  957.,  1038., 1038., 1128., 1119., 1218.,
      1362., 1488., 1443., 1578., 1524., 1668., 1605., 1758.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x4x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      526.,  544.,  562.,  580.,  814.,  844.,  874.,  904.,  952.,  988.,
      1024., 1060., 1090., 1132., 1174., 1216., 1228., 1276., 1324., 1372.,
      790.,  824.,  858.,  892.,  1149., 1194., 1239., 1284., 1680., 1752.,
      1824., 1896., 1833., 1914., 1995., 2076., 1986., 2076., 2166., 2256.,
      2139., 2238., 2337., 2436., 1329., 1398., 1467., 1536., 1833., 1914.,
      1995., 2076., 2598., 2724., 2850., 2976., 2751., 2886., 3021., 3156.,
      2904., 3048., 3192., 3336., 3057., 3210., 3363., 3516., 1869., 1974.,
      2079., 2184., 934.,  1000., 1066., 1132., 1246., 1348., 1450., 1552.,
      1312., 1420., 1528., 1636., 1378., 1492., 1606., 1720., 1444., 1564.,
      1684., 1804., 814.,  896.,  978.,  1060.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x4x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1680., 1752., 1824., 1896., 1833., 1914., 1995., 2076.,
      1986., 2076., 2166., 2256., 2139., 2238., 2337., 2436.,
      2598., 2724., 2850., 2976., 2751., 2886., 3021., 3156.,
      2904., 3048., 3192., 3336., 3057., 3210., 3363., 3516.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x4x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1072., 1676., 1976., 2276., 2576., 1672., 2418., 3567.,
      3909., 4251., 4593., 2886., 3930., 5619., 5961., 6303.,
      6645., 4110., 2104., 2864., 3020., 3176., 3332., 1936.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x4x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {3567., 3909., 4251., 4593.,
                                         5619., 5961., 6303., 6645.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x4x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2076.,  2144.,  3238.,  3352.,  3814.,  3952.,  4390.,  4552.,
      4966.,  5152.,  3212.,  3344.,  4662.,  4836.,  6855.,  7134.,
      7503.,  7818.,  8151.,  8502.,  8799.,  9186.,  5502.,  5772.,
      7542.,  7860.,  10743., 11238., 11391., 11922., 12039., 12606.,
      12687., 13290., 7806.,  8220.,  3948.,  4208.,  5326.,  5728.,
      5614.,  6040.,  5902.,  6352.,  6190.,  6664.,  3548.,  3872.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x4x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6855.,  7134.,  7503.,  7818.,  8151.,  8502.,  8799.,  9186.,
      10743., 11238., 11391., 11922., 12039., 12606., 12687., 13290.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x4x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4084.,  4152.,  4220.,  4288.,  6362.,  6476.,  6590.,  6704.,  7490.,
      7628.,  7766.,  7904.,  8618.,  8780.,  8942.,  9104.,  9746.,  9932.,
      10118., 10304., 6292.,  6424.,  6556.,  6688.,  9150.,  9324.,  9498.,
      9672.,  13431., 13710., 13989., 14268., 14691., 15006., 15321., 15636.,
      15951., 16302., 16653., 17004., 17211., 17598., 17985., 18372., 10734.,
      11004., 11274., 11544., 14766., 15084., 15402., 15720., 20991., 21486.,
      21981., 22476., 22251., 22782., 23313., 23844., 23511., 24078., 24645.,
      25212., 24771., 25374., 25977., 26580., 15198., 15612., 16026., 16440.,
      7636.,  7896.,  8156.,  8416.,  10250., 10652., 11054., 11456., 10802.,
      11228., 11654., 12080., 11354., 11804., 12254., 12704., 11906., 12380.,
      12854., 13328., 6772.,  7096.,  7420.,  7744.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x4x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      13431., 13710., 13989., 14268., 14691., 15006., 15321., 15636.,
      15951., 16302., 16653., 17004., 17211., 17598., 17985., 18372.,
      20991., 21486., 21981., 22476., 22251., 22782., 23313., 23844.,
      23511., 24078., 24645., 25212., 24771., 25374., 25977., 26580.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x4x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8232.,  12892., 15244., 17596., 19948., 12936., 18756., 27654.,
      30318., 32982., 35646., 22356., 30564., 43638., 46302., 48966.,
      51630., 31860., 16200., 21964., 23164., 24364., 25564., 14760.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x4x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {27654., 30318., 32982., 35646.,
                                         43638., 46302., 48966., 51630.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x4x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      16200.,  16464.,  25340., 25784., 29948., 30488., 34556., 35192.,
      39164.,  39896.,  25352., 25872., 36828., 37512., 54210., 55308.,
      59394.,  60636.,  64578., 65964., 69762., 71292., 43644., 44712.,
      59868.,  61128.,  85314., 87276., 90498., 92604., 95682., 97932.,
      100866., 103260., 62076., 63720., 31368., 32400., 42332., 43928.,
      44636.,  46328.,  46940., 48728., 49244., 51128., 28232., 29520.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x4x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      54210., 55308., 59394., 60636., 64578., 65964., 69762.,  71292.,
      85314., 87276., 90498., 92604., 95682., 97932., 100866., 103260.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x4x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      32136.,  32400.,  32664.,  32928.,  50236.,  50680.,  51124.,  51568.,
      59356.,  59896.,  60436.,  60976.,  68476.,  69112.,  69748.,  70384.,
      77596.,  78328.,  79060.,  79792.,  50184.,  50704.,  51224.,  51744.,
      72972.,  73656.,  74340.,  75024.,  107322., 108420., 109518., 110616.,
      117546., 118788., 120030., 121272., 127770., 129156., 130542., 131928.,
      137994., 139524., 141054., 142584., 86220.,  87288.,  88356.,  89424.,
      118476., 119736., 120996., 122256., 168666., 170628., 172590., 174552.,
      178890., 180996., 183102., 185208., 189114., 191364., 193614., 195864.,
      199338., 201732., 204126., 206520., 122508., 124152., 125796., 127440.,
      61704.,  62736.,  63768.,  64800.,  83068.,  84664.,  86260.,  87856.,
      87580.,  89272.,  90964.,  92656.,  92092.,  93880.,  95668.,  97456.,
      96604.,  98488.,  100372., 102256., 55176.,  56464.,  57752.,  59040.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x4x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      107322., 108420., 109518., 110616., 117546., 118788., 120030., 121272.,
      127770., 129156., 130542., 131928., 137994., 139524., 141054., 142584.,
      168666., 170628., 172590., 174552., 178890., 180996., 183102., 185208.,
      189114., 191364., 193614., 195864., 199338., 201732., 204126., 206520.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x5x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      111., 178., 217., 145., 231., 348., 393., 252., 363., 528.,
      573., 360., 495., 708., 753., 468., 261., 358., 379., 223.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x5x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {348., 393., 528., 573., 708., 753.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x5x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      208.,  222.,  332., 356., 404., 434., 268.,  290.,  429.,  462.,
      642.,  696.,  723., 786., 459., 504., 669.,  726.,  966.,  1056.,
      1047., 1146., 651., 720., 909., 990., 1290., 1416., 1371., 1506.,
      843.,  936.,  460., 522., 620., 716., 656.,  758.,  376.,  446.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x5x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {642.,  696.,  723.,  786.,
                                         966.,  1056., 1047., 1146.,
                                         1290., 1416., 1371., 1506.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x5x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      402.,  416.,  430.,  444.,  640.,  664.,  688.,  712.,  778.,  808.,
      838.,  868.,  514.,  536.,  558.,  580.,  825.,  858.,  891.,  924.,
      1230., 1284., 1338., 1392., 1383., 1446., 1509., 1572., 873.,  918.,
      963.,  1008., 1281., 1338., 1395., 1452., 1842., 1932., 2022., 2112.,
      1995., 2094., 2193., 2292., 1233., 1302., 1371., 1440., 1737., 1818.,
      1899., 1980., 2454., 2580., 2706., 2832., 2607., 2742., 2877., 3012.,
      1593., 1686., 1779., 1872., 858.,  920.,  982.,  1044., 1144., 1240.,
      1336., 1432., 1210., 1312., 1414., 1516., 682.,  752.,  822.,  892.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x5x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1230., 1284., 1338., 1392., 1383., 1446., 1509., 1572.,
      1842., 1932., 2022., 2112., 1995., 2094., 2193., 2292.,
      2454., 2580., 2706., 2832., 2607., 2742., 2877., 3012.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x5x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      808.,  1304., 1604., 1072., 1722., 2595., 2937., 1878., 2730., 3963.,
      4305., 2694., 3738., 5331., 5673., 3510., 1936., 2636., 2792., 1624.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x5x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2595., 2937., 3963.,
                                         4305., 5331., 5673.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x5x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1564., 1616., 2518., 2608., 3094., 3208., 2060.,  2144.,  3318.,  3444.,
      4983., 5190., 5631., 5874., 3582., 3756., 5238.,  5460.,  7575.,  7926.,
      8223., 8610., 5118., 5388., 7158., 7476., 10167., 10662., 10815., 11346.,
      6654., 7020., 3628., 3872., 4894., 5272., 5182.,  5584.,  2972.,  3248.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x5x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {4983.,  5190.,  5631.,  5874.,
                                         7575.,  7926.,  8223.,  8610.,
                                         10167., 10662., 10815., 11346.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x5x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3076.,  3128.,  3180.,  3232.,  4946.,  5036.,  5126.,  5216.,  6074.,
      6188.,  6302.,  6416.,  4036.,  4120.,  4204.,  4288.,  6510.,  6636.,
      6762.,  6888.,  9759.,  9966.,  10173., 10380., 11019., 11262., 11505.,
      11748., 6990.,  7164.,  7338.,  7512.,  10254., 10476., 10698., 10920.,
      14799., 15150., 15501., 15852., 16059., 16446., 16833., 17220., 9966.,
      10236., 10506., 10776., 13998., 14316., 14634., 14952., 19839., 20334.,
      20829., 21324., 21099., 21630., 22161., 22692., 12942., 13308., 13674.,
      14040., 7012.,  7256.,  7500.,  7744.,  9410.,  9788.,  10166., 10544.,
      9962.,  10364., 10766., 11168., 5668.,  5944.,  6220.,  6496.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x5x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      9759.,  9966.,  10173., 10380., 11019., 11262., 11505., 11748.,
      14799., 15150., 15501., 15852., 16059., 16446., 16833., 17220.,
      19839., 20334., 20829., 21324., 21099., 21630., 22161., 22692.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x5x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6152.,  9964.,  12316., 8232.,  13284., 20022., 22686.,
      14484., 21156., 30678., 33342., 20820., 29028., 41334.,
      43998., 27156., 14888., 20188., 21388., 12360.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x5x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {20022., 22686., 30678.,
                                         33342., 41334., 43998.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x5x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      12104., 12304., 19580., 19928., 24188., 24632., 16136., 16464.,
      26076., 26568., 39234., 40044., 44418., 45372., 28284., 28968.,
      41436., 42312., 59970., 61356., 65154., 66684., 40572., 41640.,
      56796., 58056., 80706., 82668., 85890., 87996., 52860., 54312.,
      28808., 29776., 38876., 40376., 41180., 42776., 23624., 24720.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x5x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {39234., 40044., 44418., 45372.,
                                         59970., 61356., 65154., 66684.,
                                         80706., 82668., 85890., 87996.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x5x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      24008.,  24208.,  24408.,  24608.,  38812.,  39160.,  39508.,  39856.,
      47932.,  48376.,  48820.,  49264.,  31944.,  32272.,  32600.,  32928.,
      51660.,  52152.,  52644.,  53136.,  77658.,  78468.,  79278.,  80088.,
      87882.,  88836.,  89790.,  90744.,  55884.,  56568.,  57252.,  57936.,
      81996.,  82872.,  83748.,  84624.,  118554., 119940., 121326., 122712.,
      128778., 130308., 131838., 133368., 80076.,  81144.,  82212.,  83280.,
      112332., 113592., 114852., 116112., 159450., 161412., 163374., 165336.,
      169674., 171780., 173886., 175992., 104268., 105720., 107172., 108624.,
      56648.,  57616.,  58584.,  59552.,  76252.,  77752.,  79252.,  80752.,
      80764.,  82360.,  83956.,  85552.,  46152.,  47248.,  48344.,  49440.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x5x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      77658.,  78468.,  79278.,  80088.,  87882.,  88836.,  89790.,  90744.,
      118554., 119940., 121326., 122712., 128778., 130308., 131838., 133368.,
      159450., 161412., 163374., 165336., 169674., 171780., 173886., 175992.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x5x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      128., 202., 241., 280., 184., 276., 411., 456., 501.,
      318., 441., 636., 681., 726., 453., 606., 861., 906.,
      951., 588., 320., 436., 457., 478., 280.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x5x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {411., 456., 501., 636., 681.,
                                         726., 861., 906., 951.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x5x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      240.,  256.,  377.,  404.,  449.,  482.,  521.,  560.,  340.,  368.,
      513.,  552.,  759.,  822.,  840.,  912.,  921.,  1002., 579.,  636.,
      813.,  882.,  1164., 1272., 1245., 1362., 1326., 1452., 819.,  906.,
      1113., 1212., 1569., 1722., 1650., 1812., 1731., 1902., 1059., 1176.,
      564.,  640.,  755.,  872.,  791.,  914.,  827.,  956.,  472.,  560.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x5x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      759.,  822.,  840.,  912.,  921.,  1002., 1164., 1272., 1245.,
      1362., 1326., 1452., 1569., 1722., 1650., 1812., 1731., 1902.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x5x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      464.,  480.,  496.,  512.,  727.,  754.,  781.,  808.,  865.,  898.,
      931.,  964.,  1003., 1042., 1081., 1120., 652.,  680.,  708.,  736.,
      987.,  1026., 1065., 1104., 1455., 1518., 1581., 1644., 1608., 1680.,
      1752., 1824., 1761., 1842., 1923., 2004., 1101., 1158., 1215., 1272.,
      1557., 1626., 1695., 1764., 2220., 2328., 2436., 2544., 2373., 2490.,
      2607., 2724., 2526., 2652., 2778., 2904., 1551., 1638., 1725., 1812.,
      2127., 2226., 2325., 2424., 2985., 3138., 3291., 3444., 3138., 3300.,
      3462., 3624., 3291., 3462., 3633., 3804., 2001., 2118., 2235., 2352.,
      1052., 1128., 1204., 1280., 1393., 1510., 1627., 1744., 1459., 1582.,
      1705., 1828., 1525., 1654., 1783., 1912., 856.,  944.,  1032., 1120.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x5x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1455., 1518., 1581., 1644., 1608., 1680., 1752., 1824., 1761.,
      1842., 1923., 2004., 2220., 2328., 2436., 2544., 2373., 2490.,
      2607., 2724., 2526., 2652., 2778., 2904., 2985., 3138., 3291.,
      3444., 3138., 3300., 3462., 3624., 3291., 3462., 3633., 3804.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x5x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      940.,  1490., 1790., 2090., 1372., 2070., 3081., 3423., 3765.,
      2382., 3330., 4791., 5133., 5475., 3402., 4590., 6501., 6843.,
      7185., 4422., 2380., 3218., 3374., 3530., 2044.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x5x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {3081., 3423., 3765., 4791., 5133.,
                                         5475., 6501., 6843., 7185.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x5x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1820.,  1880.,  2878., 2980., 3454., 3580.,  4030.,  4180.,  2636.,
      2744.,  3990.,  4140., 5919., 6162., 6567.,  6846.,  7215.,  7530.,
      4542.,  4764.,  6390., 6660., 9159., 9582.,  9807.,  10266., 10455.,
      10950., 6462.,  6804., 8790., 9180., 12399., 13002., 13047., 13686.,
      13695., 14370., 8382., 8844., 4460., 4760.,  5974.,  6436.,  6262.,
      6748.,  6550.,  7060., 3740., 4088.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x5x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5919.,  6162.,  6567.,  6846.,  7215.,  7530.,  9159.,  9582.,  9807.,
      10266., 10455., 10950., 12399., 13002., 13047., 13686., 13695., 14370.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x5x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3580.,  3640.,  3700.,  3760.,  5654.,  5756.,  5858.,  5960.,  6782.,
      6908.,  7034.,  7160.,  7910.,  8060.,  8210.,  8360.,  5164.,  5272.,
      5380.,  5488.,  7830.,  7980.,  8130.,  8280.,  11595., 11838., 12081.,
      12324., 12855., 13134., 13413., 13692., 14115., 14430., 14745., 15060.,
      8862.,  9084.,  9306.,  9528.,  12510., 12780., 13050., 13320., 17895.,
      18318., 18741., 19164., 19155., 19614., 20073., 20532., 20415., 20910.,
      21405., 21900., 12582., 12924., 13266., 13608., 17190., 17580., 17970.,
      18360., 24195., 24798., 25401., 26004., 25455., 26094., 26733., 27372.,
      26715., 27390., 28065., 28740., 16302., 16764., 17226., 17688., 8620.,
      8920.,  9220.,  9520.,  11486., 11948., 12410., 12872., 12038., 12524.,
      13010., 13496., 12590., 13100., 13610., 14120., 7132.,  7480.,  7828.,
      8176.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x5x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11595., 11838., 12081., 12324., 12855., 13134., 13413., 13692., 14115.,
      14430., 14745., 15060., 17895., 18318., 18741., 19164., 19155., 19614.,
      20073., 20532., 20415., 20910., 21405., 21900., 24195., 24798., 25401.,
      26004., 25455., 26094., 26733., 27372., 26715., 27390., 28065., 28740.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x5x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7192.,  11428., 13780., 16132., 10584., 16020., 23838., 26502., 29166.,
      18420., 25860., 37158., 39822., 42486., 26340., 35700., 50478., 53142.,
      55806., 34260., 18328., 24676., 25876., 27076., 15576.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x5x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {23838., 26502., 29166., 37158., 39822.,
                                         42486., 50478., 53142., 55806.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x5x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      14152., 14384.,  22460.,  22856.,  27068.,  27560.,  31676., 32264.,
      20744., 21168.,  31452.,  32040.,  46722.,  47676.,  51906., 53004.,
      57090., 58332.,  35964.,  36840.,  50652.,  51720.,  72642., 74316.,
      77826., 79644.,  83010.,  84972.,  51324.,  52680.,  69852., 71400.,
      98562., 100956., 103746., 106284., 108930., 111612., 66684., 68520.,
      35464., 36656.,  47516.,  49352.,  49820.,  51752.,  52124., 54152.,
      29768., 31152.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x5x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      46722., 47676.,  51906.,  53004.,  57090.,  58332.,
      72642., 74316.,  77826.,  79644.,  83010.,  84972.,
      98562., 100956., 103746., 106284., 108930., 111612.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x5x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      28072.,  28304.,  28536.,  28768.,  44524.,  44920.,  45316.,  45712.,
      53644.,  54136.,  54628.,  55120.,  62764.,  63352.,  63940.,  64528.,
      41064.,  41488.,  41912.,  42336.,  62316.,  62904.,  63492.,  64080.,
      92490.,  93444.,  94398.,  95352.,  102714., 103812., 104910., 106008.,
      112938., 114180., 115422., 116664., 71052.,  71928.,  72804.,  73680.,
      100236., 101304., 102372., 103440., 143610., 145284., 146958., 148632.,
      153834., 155652., 157470., 159288., 164058., 166020., 167982., 169944.,
      101292., 102648., 104004., 105360., 138156., 139704., 141252., 142800.,
      194730., 197124., 199518., 201912., 204954., 207492., 210030., 212568.,
      215178., 217860., 220542., 223224., 131532., 133368., 135204., 137040.,
      69736.,  70928.,  72120.,  73312.,  93196.,  95032.,  96868.,  98704.,
      97708.,  99640.,  101572., 103504., 102220., 104248., 106276., 108304.,
      58152.,  59536.,  60920.,  62304.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x5x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      92490.,  93444.,  94398.,  95352.,  102714., 103812., 104910., 106008.,
      112938., 114180., 115422., 116664., 143610., 145284., 146958., 148632.,
      153834., 155652., 157470., 159288., 164058., 166020., 167982., 169944.,
      194730., 197124., 199518., 201912., 204954., 207492., 210030., 212568.,
      215178., 217860., 220542., 223224.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x5x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      145.,  226.,  265.,  304., 343., 223., 321., 474., 519., 564.,
      609.,  384.,  519.,  744., 789., 834., 879., 546., 717., 1014.,
      1059., 1104., 1149., 708., 379., 514., 535., 556., 577., 337.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x5x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {474.,  519.,  564.,  609.,
                                         744.,  789.,  834.,  879.,
                                         1014., 1059., 1104., 1149.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x5x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      272.,  290.,  422.,  452.,  494.,  530.,  566.,  608.,  638.,  686.,
      412.,  446.,  597.,  642.,  876.,  948.,  957.,  1038., 1038., 1128.,
      1119., 1218., 699.,  768.,  957.,  1038., 1362., 1488., 1443., 1578.,
      1524., 1668., 1605., 1758., 987.,  1092., 1317., 1434., 1848., 2028.,
      1929., 2118., 2010., 2208., 2091., 2298., 1275., 1416., 668.,  758.,
      890.,  1028., 926.,  1070., 962.,  1112., 998.,  1154., 568.,  674.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x5x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      876.,  948.,  957.,  1038., 1038., 1128., 1119., 1218.,
      1362., 1488., 1443., 1578., 1524., 1668., 1605., 1758.,
      1848., 2028., 1929., 2118., 2010., 2208., 2091., 2298.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x5x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      526.,  544.,  562.,  580.,  814.,  844.,  874.,  904.,  952.,  988.,
      1024., 1060., 1090., 1132., 1174., 1216., 1228., 1276., 1324., 1372.,
      790.,  824.,  858.,  892.,  1149., 1194., 1239., 1284., 1680., 1752.,
      1824., 1896., 1833., 1914., 1995., 2076., 1986., 2076., 2166., 2256.,
      2139., 2238., 2337., 2436., 1329., 1398., 1467., 1536., 1833., 1914.,
      1995., 2076., 2598., 2724., 2850., 2976., 2751., 2886., 3021., 3156.,
      2904., 3048., 3192., 3336., 3057., 3210., 3363., 3516., 1869., 1974.,
      2079., 2184., 2517., 2634., 2751., 2868., 3516., 3696., 3876., 4056.,
      3669., 3858., 4047., 4236., 3822., 4020., 4218., 4416., 3975., 4182.,
      4389., 4596., 2409., 2550., 2691., 2832., 1246., 1336., 1426., 1516.,
      1642., 1780., 1918., 2056., 1708., 1852., 1996., 2140., 1774., 1924.,
      2074., 2224., 1840., 1996., 2152., 2308., 1030., 1136., 1242., 1348.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x5x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1680., 1752., 1824., 1896., 1833., 1914., 1995., 2076., 1986., 2076.,
      2166., 2256., 2139., 2238., 2337., 2436., 2598., 2724., 2850., 2976.,
      2751., 2886., 3021., 3156., 2904., 3048., 3192., 3336., 3057., 3210.,
      3363., 3516., 3516., 3696., 3876., 4056., 3669., 3858., 4047., 4236.,
      3822., 4020., 4218., 4416., 3975., 4182., 4389., 4596.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x5x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1072., 1676., 1976., 2276., 2576., 1672., 2418., 3567., 3909., 4251.,
      4593., 2886., 3930., 5619., 5961., 6303., 6645., 4110., 5442., 7671.,
      8013., 8355., 8697., 5334., 2824., 3800., 3956., 4112., 4268., 2464.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x5x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {3567., 3909., 4251., 4593.,
                                         5619., 5961., 6303., 6645.,
                                         7671., 8013., 8355., 8697.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x5x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2076.,  2144.,  3238.,  3352.,  3814.,  3952.,  4390.,  4552.,  4966.,
      5152.,  3212.,  3344.,  4662.,  4836.,  6855.,  7134.,  7503.,  7818.,
      8151.,  8502.,  8799.,  9186.,  5502.,  5772.,  7542.,  7860.,  10743.,
      11238., 11391., 11922., 12039., 12606., 12687., 13290., 7806.,  8220.,
      10422., 10884., 14631., 15342., 15279., 16026., 15927., 16710., 16575.,
      17394., 10110., 10668., 5292.,  5648.,  7054.,  7600.,  7342.,  7912.,
      7630.,  8224.,  7918.,  8536.,  4508.,  4928.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x5x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6855.,  7134.,  7503.,  7818.,  8151.,  8502.,  8799.,  9186.,
      10743., 11238., 11391., 11922., 12039., 12606., 12687., 13290.,
      14631., 15342., 15279., 16026., 15927., 16710., 16575., 17394.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x5x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4084.,  4152.,  4220.,  4288.,  6362.,  6476.,  6590.,  6704.,  7490.,
      7628.,  7766.,  7904.,  8618.,  8780.,  8942.,  9104.,  9746.,  9932.,
      10118., 10304., 6292.,  6424.,  6556.,  6688.,  9150.,  9324.,  9498.,
      9672.,  13431., 13710., 13989., 14268., 14691., 15006., 15321., 15636.,
      15951., 16302., 16653., 17004., 17211., 17598., 17985., 18372., 10734.,
      11004., 11274., 11544., 14766., 15084., 15402., 15720., 20991., 21486.,
      21981., 22476., 22251., 22782., 23313., 23844., 23511., 24078., 24645.,
      25212., 24771., 25374., 25977., 26580., 15198., 15612., 16026., 16440.,
      20382., 20844., 21306., 21768., 28551., 29262., 29973., 30684., 29811.,
      30558., 31305., 32052., 31071., 31854., 32637., 33420., 32331., 33150.,
      33969., 34788., 19662., 20220., 20778., 21336., 10228., 10584., 10940.,
      11296., 13562., 14108., 14654., 15200., 14114., 14684., 15254., 15824.,
      14666., 15260., 15854., 16448., 15218., 15836., 16454., 17072., 8596.,
      9016.,  9436.,  9856.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x5x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      13431., 13710., 13989., 14268., 14691., 15006., 15321., 15636.,
      15951., 16302., 16653., 17004., 17211., 17598., 17985., 18372.,
      20991., 21486., 21981., 22476., 22251., 22782., 23313., 23844.,
      23511., 24078., 24645., 25212., 24771., 25374., 25977., 26580.,
      28551., 29262., 29973., 30684., 29811., 30558., 31305., 32052.,
      31071., 31854., 32637., 33420., 32331., 33150., 33969., 34788.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x5x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8232.,  12892., 15244., 17596., 19948., 12936., 18756., 27654.,
      30318., 32982., 35646., 22356., 30564., 43638., 46302., 48966.,
      51630., 31860., 42372., 59622., 62286., 64950., 67614., 41364.,
      21768., 29164., 30364., 31564., 32764., 18792.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x5x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {27654., 30318., 32982., 35646.,
                                         43638., 46302., 48966., 51630.,
                                         59622., 62286., 64950., 67614.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x5x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      16200.,  16464.,  25340.,  25784.,  29948.,  30488.,  34556.,  35192.,
      39164.,  39896.,  25352.,  25872.,  36828.,  37512.,  54210.,  55308.,
      59394.,  60636.,  64578.,  65964.,  69762.,  71292.,  43644.,  44712.,
      59868.,  61128.,  85314.,  87276.,  90498.,  92604.,  95682.,  97932.,
      100866., 103260., 62076.,  63720.,  82908.,  84744.,  116418., 119244.,
      121602., 124572., 126786., 129900., 131970., 135228., 80508.,  82728.,
      42120.,  43536.,  56156.,  58328.,  58460.,  60728.,  60764.,  63128.,
      63068.,  65528.,  35912.,  37584.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x5x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      54210.,  55308.,  59394.,  60636.,  64578.,  65964.,  69762.,  71292.,
      85314.,  87276.,  90498.,  92604.,  95682.,  97932.,  100866., 103260.,
      116418., 119244., 121602., 124572., 126786., 129900., 131970., 135228.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x5x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      32136.,  32400.,  32664.,  32928.,  50236.,  50680.,  51124.,  51568.,
      59356.,  59896.,  60436.,  60976.,  68476.,  69112.,  69748.,  70384.,
      77596.,  78328.,  79060.,  79792.,  50184.,  50704.,  51224.,  51744.,
      72972.,  73656.,  74340.,  75024.,  107322., 108420., 109518., 110616.,
      117546., 118788., 120030., 121272., 127770., 129156., 130542., 131928.,
      137994., 139524., 141054., 142584., 86220.,  87288.,  88356.,  89424.,
      118476., 119736., 120996., 122256., 168666., 170628., 172590., 174552.,
      178890., 180996., 183102., 185208., 189114., 191364., 193614., 195864.,
      199338., 201732., 204126., 206520., 122508., 124152., 125796., 127440.,
      163980., 165816., 167652., 169488., 230010., 232836., 235662., 238488.,
      240234., 243204., 246174., 249144., 250458., 253572., 256686., 259800.,
      260682., 263940., 267198., 270456., 158796., 161016., 163236., 165456.,
      82824.,  84240.,  85656.,  87072.,  110140., 112312., 114484., 116656.,
      114652., 116920., 119188., 121456., 119164., 121528., 123892., 126256.,
      123676., 126136., 128596., 131056., 70152.,  71824.,  73496.,  75168.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x5x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      107322., 108420., 109518., 110616., 117546., 118788., 120030., 121272.,
      127770., 129156., 130542., 131928., 137994., 139524., 141054., 142584.,
      168666., 170628., 172590., 174552., 178890., 180996., 183102., 185208.,
      189114., 191364., 193614., 195864., 199338., 201732., 204126., 206520.,
      230010., 232836., 235662., 238488., 240234., 243204., 246174., 249144.,
      250458., 253572., 256686., 259800., 260682., 263940., 267198., 270456.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x6x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      111., 178., 217., 145., 231., 348., 393., 252., 363., 528., 573., 360.,
      495., 708., 753., 468., 627., 888., 933., 576., 325., 442., 463., 271.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x6x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {348., 393., 528., 573.,
                                         708., 753., 888., 933.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x6x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      208.,  222.,  332.,  356.,  404.,  434.,  268.,  290.,  429.,  462.,
      642.,  696.,  723.,  786.,  459.,  504.,  669.,  726.,  966.,  1056.,
      1047., 1146., 651.,  720.,  909.,  990.,  1290., 1416., 1371., 1506.,
      843.,  936.,  1149., 1254., 1614., 1776., 1695., 1866., 1035., 1152.,
      572.,  650.,  764.,  884.,  800.,  926.,  456.,  542.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x6x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      642.,  696.,  723.,  786.,  966.,  1056., 1047., 1146.,
      1290., 1416., 1371., 1506., 1614., 1776., 1695., 1866.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x6x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      402.,  416.,  430.,  444.,  640.,  664.,  688.,  712.,  778.,  808.,
      838.,  868.,  514.,  536.,  558.,  580.,  825.,  858.,  891.,  924.,
      1230., 1284., 1338., 1392., 1383., 1446., 1509., 1572., 873.,  918.,
      963.,  1008., 1281., 1338., 1395., 1452., 1842., 1932., 2022., 2112.,
      1995., 2094., 2193., 2292., 1233., 1302., 1371., 1440., 1737., 1818.,
      1899., 1980., 2454., 2580., 2706., 2832., 2607., 2742., 2877., 3012.,
      1593., 1686., 1779., 1872., 2193., 2298., 2403., 2508., 3066., 3228.,
      3390., 3552., 3219., 3390., 3561., 3732., 1953., 2070., 2187., 2304.,
      1066., 1144., 1222., 1300., 1408., 1528., 1648., 1768., 1474., 1600.,
      1726., 1852., 826.,  912.,  998.,  1084.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x6x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1230., 1284., 1338., 1392., 1383., 1446., 1509., 1572.,
      1842., 1932., 2022., 2112., 1995., 2094., 2193., 2292.,
      2454., 2580., 2706., 2832., 2607., 2742., 2877., 3012.,
      3066., 3228., 3390., 3552., 3219., 3390., 3561., 3732.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x6x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      808.,  1304., 1604., 1072., 1722., 2595., 2937., 1878.,
      2730., 3963., 4305., 2694., 3738., 5331., 5673., 3510.,
      4746., 6699., 7041., 4326., 2416., 3260., 3416., 1976.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x6x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2595., 2937., 3963., 4305.,
                                         5331., 5673., 6699., 7041.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x6x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1564., 1616., 2518.,  2608.,  3094.,  3208.,  2060., 2144.,
      3318., 3444., 4983.,  5190.,  5631.,  5874.,  3582., 3756.,
      5238., 5460., 7575.,  7926.,  8223.,  8610.,  5118., 5388.,
      7158., 7476., 10167., 10662., 10815., 11346., 6654., 7020.,
      9078., 9492., 12759., 13398., 13407., 14082., 8190., 8652.,
      4524., 4832., 6046.,  6520.,  6334.,  6832.,  3612., 3952.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x6x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4983.,  5190.,  5631.,  5874.,  7575.,  7926.,  8223.,  8610.,
      10167., 10662., 10815., 11346., 12759., 13398., 13407., 14082.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x6x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3076.,  3128.,  3180.,  3232.,  4946.,  5036.,  5126.,  5216.,  6074.,
      6188.,  6302.,  6416.,  4036.,  4120.,  4204.,  4288.,  6510.,  6636.,
      6762.,  6888.,  9759.,  9966.,  10173., 10380., 11019., 11262., 11505.,
      11748., 6990.,  7164.,  7338.,  7512.,  10254., 10476., 10698., 10920.,
      14799., 15150., 15501., 15852., 16059., 16446., 16833., 17220., 9966.,
      10236., 10506., 10776., 13998., 14316., 14634., 14952., 19839., 20334.,
      20829., 21324., 21099., 21630., 22161., 22692., 12942., 13308., 13674.,
      14040., 17742., 18156., 18570., 18984., 24879., 25518., 26157., 26796.,
      26139., 26814., 27489., 28164., 15918., 16380., 16842., 17304., 8740.,
      9048.,  9356.,  9664.,  11618., 12092., 12566., 13040., 12170., 12668.,
      13166., 13664., 6884.,  7224.,  7564.,  7904.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x6x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      9759.,  9966.,  10173., 10380., 11019., 11262., 11505., 11748.,
      14799., 15150., 15501., 15852., 16059., 16446., 16833., 17220.,
      19839., 20334., 20829., 21324., 21099., 21630., 22161., 22692.,
      24879., 25518., 26157., 26796., 26139., 26814., 27489., 28164.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x6x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6152.,  9964.,  12316., 8232.,  13284., 20022., 22686., 14484.,
      21156., 30678., 33342., 20820., 29028., 41334., 43998., 27156.,
      36900., 51990., 54654., 33492., 18600., 24988., 26188., 15048.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x6x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {20022., 22686., 30678., 33342.,
                                         41334., 43998., 51990., 54654.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x6x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      12104., 12304., 19580.,  19928.,  24188.,  24632.,  16136., 16464.,
      26076., 26568., 39234.,  40044.,  44418.,  45372.,  28284., 28968.,
      41436., 42312., 59970.,  61356.,  65154.,  66684.,  40572., 41640.,
      56796., 58056., 80706.,  82668.,  85890.,  87996.,  52860., 54312.,
      72156., 73800., 101442., 103980., 106626., 109308., 65148., 66984.,
      35976., 37200., 48092.,  49976.,  50396.,  52376.,  28744., 30096.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x6x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      39234., 40044., 44418., 45372., 59970.,  61356.,  65154.,  66684.,
      80706., 82668., 85890., 87996., 101442., 103980., 106626., 109308.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x6x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      24008.,  24208.,  24408.,  24608.,  38812.,  39160.,  39508.,  39856.,
      47932.,  48376.,  48820.,  49264.,  31944.,  32272.,  32600.,  32928.,
      51660.,  52152.,  52644.,  53136.,  77658.,  78468.,  79278.,  80088.,
      87882.,  88836.,  89790.,  90744.,  55884.,  56568.,  57252.,  57936.,
      81996.,  82872.,  83748.,  84624.,  118554., 119940., 121326., 122712.,
      128778., 130308., 131838., 133368., 80076.,  81144.,  82212.,  83280.,
      112332., 113592., 114852., 116112., 159450., 161412., 163374., 165336.,
      169674., 171780., 173886., 175992., 104268., 105720., 107172., 108624.,
      142668., 144312., 145956., 147600., 200346., 202884., 205422., 207960.,
      210570., 213252., 215934., 218616., 128460., 130296., 132132., 133968.,
      70728.,  71952.,  73176.,  74400.,  94300.,  96184.,  98068.,  99952.,
      98812.,  100792., 102772., 104752., 56136.,  57488.,  58840.,  60192.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x6x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      77658.,  78468.,  79278.,  80088.,  87882.,  88836.,  89790.,  90744.,
      118554., 119940., 121326., 122712., 128778., 130308., 131838., 133368.,
      159450., 161412., 163374., 165336., 169674., 171780., 173886., 175992.,
      200346., 202884., 205422., 207960., 210570., 213252., 215934., 218616.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x6x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      128., 202.,  241.,  280.,  184., 276., 411., 456., 501., 318.,
      441., 636.,  681.,  726.,  453., 606., 861., 906., 951., 588.,
      771., 1086., 1131., 1176., 723., 400., 541., 562., 583., 340.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x6x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {411., 456., 501., 636.,  681.,  726.,
                                         861., 906., 951., 1086., 1131., 1176.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x6x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      240.,  256.,  377.,  404.,  449.,  482.,  521.,  560.,  340.,  368.,
      513.,  552.,  759.,  822.,  840.,  912.,  921.,  1002., 579.,  636.,
      813.,  882.,  1164., 1272., 1245., 1362., 1326., 1452., 819.,  906.,
      1113., 1212., 1569., 1722., 1650., 1812., 1731., 1902., 1059., 1176.,
      1413., 1542., 1974., 2172., 2055., 2262., 2136., 2352., 1299., 1446.,
      704.,  800.,  935.,  1082., 971.,  1124., 1007., 1166., 572.,  680.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x6x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      759.,  822.,  840.,  912.,  921.,  1002., 1164., 1272.,
      1245., 1362., 1326., 1452., 1569., 1722., 1650., 1812.,
      1731., 1902., 1974., 2172., 2055., 2262., 2136., 2352.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x6x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      464.,  480.,  496.,  512.,  727.,  754.,  781.,  808.,  865.,  898.,
      931.,  964.,  1003., 1042., 1081., 1120., 652.,  680.,  708.,  736.,
      987.,  1026., 1065., 1104., 1455., 1518., 1581., 1644., 1608., 1680.,
      1752., 1824., 1761., 1842., 1923., 2004., 1101., 1158., 1215., 1272.,
      1557., 1626., 1695., 1764., 2220., 2328., 2436., 2544., 2373., 2490.,
      2607., 2724., 2526., 2652., 2778., 2904., 1551., 1638., 1725., 1812.,
      2127., 2226., 2325., 2424., 2985., 3138., 3291., 3444., 3138., 3300.,
      3462., 3624., 3291., 3462., 3633., 3804., 2001., 2118., 2235., 2352.,
      2697., 2826., 2955., 3084., 3750., 3948., 4146., 4344., 3903., 4110.,
      4317., 4524., 4056., 4272., 4488., 4704., 2451., 2598., 2745., 2892.,
      1312., 1408., 1504., 1600., 1723., 1870., 2017., 2164., 1789., 1942.,
      2095., 2248., 1855., 2014., 2173., 2332., 1036., 1144., 1252., 1360.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x6x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1455., 1518., 1581., 1644., 1608., 1680., 1752., 1824., 1761., 1842.,
      1923., 2004., 2220., 2328., 2436., 2544., 2373., 2490., 2607., 2724.,
      2526., 2652., 2778., 2904., 2985., 3138., 3291., 3444., 3138., 3300.,
      3462., 3624., 3291., 3462., 3633., 3804., 3750., 3948., 4146., 4344.,
      3903., 4110., 4317., 4524., 4056., 4272., 4488., 4704.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x6x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      940.,  1490., 1790., 2090., 1372., 2070., 3081., 3423., 3765., 2382.,
      3330., 4791., 5133., 5475., 3402., 4590., 6501., 6843., 7185., 4422.,
      5850., 8211., 8553., 8895., 5442., 2980., 3998., 4154., 4310., 2484.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x6x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {3081., 3423., 3765., 4791.,
                                         5133., 5475., 6501., 6843.,
                                         7185., 8211., 8553., 8895.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x6x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1820.,  1880.,  2878.,  2980.,  3454.,  3580.,  4030.,  4180.,  2636.,
      2744.,  3990.,  4140.,  5919.,  6162.,  6567.,  6846.,  7215.,  7530.,
      4542.,  4764.,  6390.,  6660.,  9159.,  9582.,  9807.,  10266., 10455.,
      10950., 6462.,  6804.,  8790.,  9180.,  12399., 13002., 13047., 13686.,
      13695., 14370., 8382.,  8844.,  11190., 11700., 15639., 16422., 16287.,
      17106., 16935., 17790., 10302., 10884., 5580.,  5960.,  7414.,  7996.,
      7702.,  8308.,  7990.,  8620.,  4540.,  4968.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x6x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5919.,  6162.,  6567.,  6846.,  7215.,  7530.,  9159.,  9582.,
      9807.,  10266., 10455., 10950., 12399., 13002., 13047., 13686.,
      13695., 14370., 15639., 16422., 16287., 17106., 16935., 17790.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x6x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3580.,  3640.,  3700.,  3760.,  5654.,  5756.,  5858.,  5960.,  6782.,
      6908.,  7034.,  7160.,  7910.,  8060.,  8210.,  8360.,  5164.,  5272.,
      5380.,  5488.,  7830.,  7980.,  8130.,  8280.,  11595., 11838., 12081.,
      12324., 12855., 13134., 13413., 13692., 14115., 14430., 14745., 15060.,
      8862.,  9084.,  9306.,  9528.,  12510., 12780., 13050., 13320., 17895.,
      18318., 18741., 19164., 19155., 19614., 20073., 20532., 20415., 20910.,
      21405., 21900., 12582., 12924., 13266., 13608., 17190., 17580., 17970.,
      18360., 24195., 24798., 25401., 26004., 25455., 26094., 26733., 27372.,
      26715., 27390., 28065., 28740., 16302., 16764., 17226., 17688., 21870.,
      22380., 22890., 23400., 30495., 31278., 32061., 32844., 31755., 32574.,
      33393., 34212., 33015., 33870., 34725., 35580., 20022., 20604., 21186.,
      21768., 10780., 11160., 11540., 11920., 14246., 14828., 15410., 15992.,
      14798., 15404., 16010., 16616., 15350., 15980., 16610., 17240., 8652.,
      9080.,  9508.,  9936.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x6x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11595., 11838., 12081., 12324., 12855., 13134., 13413., 13692.,
      14115., 14430., 14745., 15060., 17895., 18318., 18741., 19164.,
      19155., 19614., 20073., 20532., 20415., 20910., 21405., 21900.,
      24195., 24798., 25401., 26004., 25455., 26094., 26733., 27372.,
      26715., 27390., 28065., 28740., 30495., 31278., 32061., 32844.,
      31755., 32574., 33393., 34212., 33015., 33870., 34725., 35580.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x6x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7192.,  11428., 13780., 16132., 10584., 16020., 23838., 26502.,
      29166., 18420., 25860., 37158., 39822., 42486., 26340., 35700.,
      50478., 53142., 55806., 34260., 45540., 63798., 66462., 69126.,
      42180., 22968., 30676., 31876., 33076., 18936.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x6x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {23838., 26502., 29166., 37158.,
                                         39822., 42486., 50478., 53142.,
                                         55806., 63798., 66462., 69126.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x6x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      14152., 14384.,  22460.,  22856.,  27068.,  27560.,  31676.,  32264.,
      20744., 21168.,  31452.,  32040.,  46722.,  47676.,  51906.,  53004.,
      57090., 58332.,  35964.,  36840.,  50652.,  51720.,  72642.,  74316.,
      77826., 79644.,  83010.,  84972.,  51324.,  52680.,  69852.,  71400.,
      98562., 100956., 103746., 106284., 108930., 111612., 66684.,  68520.,
      89052., 91080.,  124482., 127596., 129666., 132924., 134850., 138252.,
      82044., 84360.,  44424.,  45936.,  59036.,  61352.,  61340.,  63752.,
      63644., 66152.,  36168.,  37872.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x6x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      46722.,  47676.,  51906.,  53004.,  57090.,  58332.,  72642.,  74316.,
      77826.,  79644.,  83010.,  84972.,  98562.,  100956., 103746., 106284.,
      108930., 111612., 124482., 127596., 129666., 132924., 134850., 138252.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x6x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      28072.,  28304.,  28536.,  28768.,  44524.,  44920.,  45316.,  45712.,
      53644.,  54136.,  54628.,  55120.,  62764.,  63352.,  63940.,  64528.,
      41064.,  41488.,  41912.,  42336.,  62316.,  62904.,  63492.,  64080.,
      92490.,  93444.,  94398.,  95352.,  102714., 103812., 104910., 106008.,
      112938., 114180., 115422., 116664., 71052.,  71928.,  72804.,  73680.,
      100236., 101304., 102372., 103440., 143610., 145284., 146958., 148632.,
      153834., 155652., 157470., 159288., 164058., 166020., 167982., 169944.,
      101292., 102648., 104004., 105360., 138156., 139704., 141252., 142800.,
      194730., 197124., 199518., 201912., 204954., 207492., 210030., 212568.,
      215178., 217860., 220542., 223224., 131532., 133368., 135204., 137040.,
      176076., 178104., 180132., 182160., 245850., 248964., 252078., 255192.,
      256074., 259332., 262590., 265848., 266298., 269700., 273102., 276504.,
      161772., 164088., 166404., 168720., 87336.,  88848.,  90360.,  91872.,
      115756., 118072., 120388., 122704., 120268., 122680., 125092., 127504.,
      124780., 127288., 129796., 132304., 70632.,  72336.,  74040.,  75744.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x6x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      92490.,  93444.,  94398.,  95352.,  102714., 103812., 104910., 106008.,
      112938., 114180., 115422., 116664., 143610., 145284., 146958., 148632.,
      153834., 155652., 157470., 159288., 164058., 166020., 167982., 169944.,
      194730., 197124., 199518., 201912., 204954., 207492., 210030., 212568.,
      215178., 217860., 220542., 223224., 245850., 248964., 252078., 255192.,
      256074., 259332., 262590., 265848., 266298., 269700., 273102., 276504.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x6x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      145.,  226.,  265.,  304.,  343.,  223., 321., 474.,  519.,
      564.,  609.,  384.,  519.,  744.,  789., 834., 879.,  546.,
      717.,  1014., 1059., 1104., 1149., 708., 915., 1284., 1329.,
      1374., 1419., 870.,  475.,  640.,  661., 682., 703.,  409.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x6x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      474.,  519.,  564.,  609.,  744.,  789.,  834.,  879.,
      1014., 1059., 1104., 1149., 1284., 1329., 1374., 1419.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x6x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      272.,  290.,  422.,  452.,  494.,  530.,  566.,  608.,  638.,
      686.,  412.,  446.,  597.,  642.,  876.,  948.,  957.,  1038.,
      1038., 1128., 1119., 1218., 699.,  768.,  957.,  1038., 1362.,
      1488., 1443., 1578., 1524., 1668., 1605., 1758., 987.,  1092.,
      1317., 1434., 1848., 2028., 1929., 2118., 2010., 2208., 2091.,
      2298., 1275., 1416., 1677., 1830., 2334., 2568., 2415., 2658.,
      2496., 2748., 2577., 2838., 1563., 1740., 836.,  950.,  1106.,
      1280., 1142., 1322., 1178., 1364., 1214., 1406., 688.,  818.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x6x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      876.,  948.,  957.,  1038., 1038., 1128., 1119., 1218.,
      1362., 1488., 1443., 1578., 1524., 1668., 1605., 1758.,
      1848., 2028., 1929., 2118., 2010., 2208., 2091., 2298.,
      2334., 2568., 2415., 2658., 2496., 2748., 2577., 2838.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x6x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      526.,  544.,  562.,  580.,  814.,  844.,  874.,  904.,  952.,  988.,
      1024., 1060., 1090., 1132., 1174., 1216., 1228., 1276., 1324., 1372.,
      790.,  824.,  858.,  892.,  1149., 1194., 1239., 1284., 1680., 1752.,
      1824., 1896., 1833., 1914., 1995., 2076., 1986., 2076., 2166., 2256.,
      2139., 2238., 2337., 2436., 1329., 1398., 1467., 1536., 1833., 1914.,
      1995., 2076., 2598., 2724., 2850., 2976., 2751., 2886., 3021., 3156.,
      2904., 3048., 3192., 3336., 3057., 3210., 3363., 3516., 1869., 1974.,
      2079., 2184., 2517., 2634., 2751., 2868., 3516., 3696., 3876., 4056.,
      3669., 3858., 4047., 4236., 3822., 4020., 4218., 4416., 3975., 4182.,
      4389., 4596., 2409., 2550., 2691., 2832., 3201., 3354., 3507., 3660.,
      4434., 4668., 4902., 5136., 4587., 4830., 5073., 5316., 4740., 4992.,
      5244., 5496., 4893., 5154., 5415., 5676., 2949., 3126., 3303., 3480.,
      1558., 1672., 1786., 1900., 2038., 2212., 2386., 2560., 2104., 2284.,
      2464., 2644., 2170., 2356., 2542., 2728., 2236., 2428., 2620., 2812.,
      1246., 1376., 1506., 1636.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x6x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1680., 1752., 1824., 1896., 1833., 1914., 1995., 2076., 1986., 2076.,
      2166., 2256., 2139., 2238., 2337., 2436., 2598., 2724., 2850., 2976.,
      2751., 2886., 3021., 3156., 2904., 3048., 3192., 3336., 3057., 3210.,
      3363., 3516., 3516., 3696., 3876., 4056., 3669., 3858., 4047., 4236.,
      3822., 4020., 4218., 4416., 3975., 4182., 4389., 4596., 4434., 4668.,
      4902., 5136., 4587., 4830., 5073., 5316., 4740., 4992., 5244., 5496.,
      4893., 5154., 5415., 5676.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x6x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1072.,  1676.,  1976., 2276., 2576., 1672., 2418., 3567., 3909.,
      4251.,  4593.,  2886., 3930., 5619., 5961., 6303., 6645., 4110.,
      5442.,  7671.,  8013., 8355., 8697., 5334., 6954., 9723., 10065.,
      10407., 10749., 6558., 3544., 4736., 4892., 5048., 5204., 2992.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x6x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3567., 3909., 4251., 4593., 5619., 5961.,  6303.,  6645.,
      7671., 8013., 8355., 8697., 9723., 10065., 10407., 10749.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x6x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2076.,  2144.,  3238.,  3352.,  3814.,  3952.,  4390.,  4552.,  4966.,
      5152.,  3212.,  3344.,  4662.,  4836.,  6855.,  7134.,  7503.,  7818.,
      8151.,  8502.,  8799.,  9186.,  5502.,  5772.,  7542.,  7860.,  10743.,
      11238., 11391., 11922., 12039., 12606., 12687., 13290., 7806.,  8220.,
      10422., 10884., 14631., 15342., 15279., 16026., 15927., 16710., 16575.,
      17394., 10110., 10668., 13302., 13908., 18519., 19446., 19167., 20130.,
      19815., 20814., 20463., 21498., 12414., 13116., 6636.,  7088.,  8782.,
      9472.,  9070.,  9784.,  9358.,  10096., 9646.,  10408., 5468.,  5984.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x6x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6855.,  7134.,  7503.,  7818.,  8151.,  8502.,  8799.,  9186.,
      10743., 11238., 11391., 11922., 12039., 12606., 12687., 13290.,
      14631., 15342., 15279., 16026., 15927., 16710., 16575., 17394.,
      18519., 19446., 19167., 20130., 19815., 20814., 20463., 21498.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x6x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4084.,  4152.,  4220.,  4288.,  6362.,  6476.,  6590.,  6704.,  7490.,
      7628.,  7766.,  7904.,  8618.,  8780.,  8942.,  9104.,  9746.,  9932.,
      10118., 10304., 6292.,  6424.,  6556.,  6688.,  9150.,  9324.,  9498.,
      9672.,  13431., 13710., 13989., 14268., 14691., 15006., 15321., 15636.,
      15951., 16302., 16653., 17004., 17211., 17598., 17985., 18372., 10734.,
      11004., 11274., 11544., 14766., 15084., 15402., 15720., 20991., 21486.,
      21981., 22476., 22251., 22782., 23313., 23844., 23511., 24078., 24645.,
      25212., 24771., 25374., 25977., 26580., 15198., 15612., 16026., 16440.,
      20382., 20844., 21306., 21768., 28551., 29262., 29973., 30684., 29811.,
      30558., 31305., 32052., 31071., 31854., 32637., 33420., 32331., 33150.,
      33969., 34788., 19662., 20220., 20778., 21336., 25998., 26604., 27210.,
      27816., 36111., 37038., 37965., 38892., 37371., 38334., 39297., 40260.,
      38631., 39630., 40629., 41628., 39891., 40926., 41961., 42996., 24126.,
      24828., 25530., 26232., 12820., 13272., 13724., 14176., 16874., 17564.,
      18254., 18944., 17426., 18140., 18854., 19568., 17978., 18716., 19454.,
      20192., 18530., 19292., 20054., 20816., 10420., 10936., 11452., 11968.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x6x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      13431., 13710., 13989., 14268., 14691., 15006., 15321., 15636.,
      15951., 16302., 16653., 17004., 17211., 17598., 17985., 18372.,
      20991., 21486., 21981., 22476., 22251., 22782., 23313., 23844.,
      23511., 24078., 24645., 25212., 24771., 25374., 25977., 26580.,
      28551., 29262., 29973., 30684., 29811., 30558., 31305., 32052.,
      31071., 31854., 32637., 33420., 32331., 33150., 33969., 34788.,
      36111., 37038., 37965., 38892., 37371., 38334., 39297., 40260.,
      38631., 39630., 40629., 41628., 39891., 40926., 41961., 42996.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x6x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8232.,  12892., 15244., 17596., 19948., 12936., 18756., 27654., 30318.,
      32982., 35646., 22356., 30564., 43638., 46302., 48966., 51630., 31860.,
      42372., 59622., 62286., 64950., 67614., 41364., 54180., 75606., 78270.,
      80934., 83598., 50868., 27336., 36364., 37564., 38764., 39964., 22824.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x6x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      27654., 30318., 32982., 35646., 43638., 46302., 48966., 51630.,
      59622., 62286., 64950., 67614., 75606., 78270., 80934., 83598.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x6x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      16200.,  16464.,  25340.,  25784.,  29948.,  30488.,  34556.,  35192.,
      39164.,  39896.,  25352.,  25872.,  36828.,  37512.,  54210.,  55308.,
      59394.,  60636.,  64578.,  65964.,  69762.,  71292.,  43644.,  44712.,
      59868.,  61128.,  85314.,  87276.,  90498.,  92604.,  95682.,  97932.,
      100866., 103260., 62076.,  63720.,  82908.,  84744.,  116418., 119244.,
      121602., 124572., 126786., 129900., 131970., 135228., 80508.,  82728.,
      105948., 108360., 147522., 151212., 152706., 156540., 157890., 161868.,
      163074., 167196., 98940.,  101736., 52872.,  54672.,  69980.,  72728.,
      72284.,  75128.,  74588.,  77528.,  76892.,  79928.,  43592.,  45648.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x6x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      54210.,  55308.,  59394.,  60636.,  64578.,  65964.,  69762.,  71292.,
      85314.,  87276.,  90498.,  92604.,  95682.,  97932.,  100866., 103260.,
      116418., 119244., 121602., 124572., 126786., 129900., 131970., 135228.,
      147522., 151212., 152706., 156540., 157890., 161868., 163074., 167196.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME1x6x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      32136.,  32400.,  32664.,  32928.,  50236.,  50680.,  51124.,  51568.,
      59356.,  59896.,  60436.,  60976.,  68476.,  69112.,  69748.,  70384.,
      77596.,  78328.,  79060.,  79792.,  50184.,  50704.,  51224.,  51744.,
      72972.,  73656.,  74340.,  75024.,  107322., 108420., 109518., 110616.,
      117546., 118788., 120030., 121272., 127770., 129156., 130542., 131928.,
      137994., 139524., 141054., 142584., 86220.,  87288.,  88356.,  89424.,
      118476., 119736., 120996., 122256., 168666., 170628., 172590., 174552.,
      178890., 180996., 183102., 185208., 189114., 191364., 193614., 195864.,
      199338., 201732., 204126., 206520., 122508., 124152., 125796., 127440.,
      163980., 165816., 167652., 169488., 230010., 232836., 235662., 238488.,
      240234., 243204., 246174., 249144., 250458., 253572., 256686., 259800.,
      260682., 263940., 267198., 270456., 158796., 161016., 163236., 165456.,
      209484., 211896., 214308., 216720., 291354., 295044., 298734., 302424.,
      301578., 305412., 309246., 313080., 311802., 315780., 319758., 323736.,
      322026., 326148., 330270., 334392., 195084., 197880., 200676., 203472.,
      103944., 105744., 107544., 109344., 137212., 139960., 142708., 145456.,
      141724., 144568., 147412., 150256., 146236., 149176., 152116., 155056.,
      150748., 153784., 156820., 159856., 85128.,  87184.,  89240.,  91296.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID1x6x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      107322., 108420., 109518., 110616., 117546., 118788., 120030., 121272.,
      127770., 129156., 130542., 131928., 137994., 139524., 141054., 142584.,
      168666., 170628., 172590., 174552., 178890., 180996., 183102., 185208.,
      189114., 191364., 193614., 195864., 199338., 201732., 204126., 206520.,
      230010., 232836., 235662., 238488., 240234., 243204., 246174., 249144.,
      250458., 253572., 256686., 259800., 260682., 263940., 267198., 270456.,
      291354., 295044., 298734., 302424., 301578., 305412., 309246., 313080.,
      311802., 315780., 319758., 323736., 322026., 326148., 330270., 334392.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x4x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      111.,  178.,  217.,  145.,  231.,  348.,  393.,  252.,  363.,  528.,
      573.,  360.,  197.,  274.,  295.,  175.,  559.,  802.,  841.,  529.,
      759.,  1068., 1113., 684.,  891.,  1248., 1293., 792.,  453.,  610.,
      631.,  367.,  1007., 1426., 1465., 913.,  1287., 1788., 1833., 1116.,
      1419., 1968., 2013., 1224., 709.,  946.,  967.,  559.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x4x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {348.,  393.,  528.,  573.,
                                         1068., 1113., 1248., 1293.,
                                         1788., 1833., 1968., 2013.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x4x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      208.,  222.,  332.,  356.,  404.,  434.,  268.,  290.,  429.,  462.,
      642.,  696.,  723.,  786.,  459.,  504.,  669.,  726.,  966.,  1056.,
      1047., 1146., 651.,  720.,  348.,  394.,  476.,  548.,  512.,  590.,
      296.,  350.,  1040., 1118., 1484., 1604., 1556., 1682., 972.,  1058.,
      1389., 1518., 1938., 2136., 2019., 2226., 1227., 1368., 1629., 1782.,
      2262., 2496., 2343., 2586., 1419., 1584., 796.,  906.,  1052., 1220.,
      1088., 1262., 616.,  734.,  1872., 2014., 2636., 2852., 2708., 2930.,
      1676., 1826., 2349., 2574., 3234., 3576., 3315., 3666., 1995., 2232.,
      2589., 2838., 3558., 3936., 3639., 4026., 2187., 2448., 1244., 1418.,
      1628., 1892., 1664., 1934., 936.,  1118.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x4x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      642.,  696.,  723.,  786.,  966.,  1056., 1047., 1146.,
      1938., 2136., 2019., 2226., 2262., 2496., 2343., 2586.,
      3234., 3576., 3315., 3666., 3558., 3936., 3639., 4026.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x4x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      402.,  416.,  430.,  444.,  640.,  664.,  688.,  712.,  778.,  808.,
      838.,  868.,  514.,  536.,  558.,  580.,  825.,  858.,  891.,  924.,
      1230., 1284., 1338., 1392., 1383., 1446., 1509., 1572., 873.,  918.,
      963.,  1008., 1281., 1338., 1395., 1452., 1842., 1932., 2022., 2112.,
      1995., 2094., 2193., 2292., 1233., 1302., 1371., 1440., 650.,  696.,
      742.,  788.,  880.,  952.,  1024., 1096., 946.,  1024., 1102., 1180.,
      538.,  592.,  646.,  700.,  2002., 2080., 2158., 2236., 2848., 2968.,
      3088., 3208., 2986., 3112., 3238., 3364., 1858., 1944., 2030., 2116.,
      2649., 2778., 2907., 3036., 3678., 3876., 4074., 4272., 3831., 4038.,
      4245., 4452., 2313., 2454., 2595., 2736., 3105., 3258., 3411., 3564.,
      4290., 4524., 4758., 4992., 4443., 4686., 4929., 5172., 2673., 2838.,
      3003., 3168., 1482., 1592., 1702., 1812., 1936., 2104., 2272., 2440.,
      2002., 2176., 2350., 2524., 1114., 1232., 1350., 1468., 3602., 3744.,
      3886., 4028., 5056., 5272., 5488., 5704., 5194., 5416., 5638., 5860.,
      3202., 3352., 3502., 3652., 4473., 4698., 4923., 5148., 6126., 6468.,
      6810., 7152., 6279., 6630., 6981., 7332., 3753., 3990., 4227., 4464.,
      4929., 5178., 5427., 5676., 6738., 7116., 7494., 7872., 6891., 7278.,
      7665., 8052., 4113., 4374., 4635., 4896., 2314., 2488., 2662., 2836.,
      2992., 3256., 3520., 3784., 3058., 3328., 3598., 3868., 1690., 1872.,
      2054., 2236.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x4x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1230., 1284., 1338., 1392., 1383., 1446., 1509., 1572., 1842., 1932.,
      2022., 2112., 1995., 2094., 2193., 2292., 3678., 3876., 4074., 4272.,
      3831., 4038., 4245., 4452., 4290., 4524., 4758., 4992., 4443., 4686.,
      4929., 5172., 6126., 6468., 6810., 7152., 6279., 6630., 6981., 7332.,
      6738., 7116., 7494., 7872., 6891., 7278., 7665., 8052.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x4x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      808.,   1304.,  1604.,  1072., 1722., 2595.,  2937.,  1878.,
      2730.,  3963.,  4305.,  2694., 1456., 2012.,  2168.,  1272.,
      4264.,  6104.,  6404.,  4016., 5754., 8067.,  8409.,  5142.,
      6762.,  9435.,  9777.,  5958., 3376., 4508.,  4664.,  2680.,
      7720.,  10904., 11204., 6960., 9786., 13539., 13881., 8406.,
      10794., 14907., 15249., 9222., 5296., 7004.,  7160.,  4088.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x4x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2595.,  2937.,  3963.,  4305.,
                                         8067.,  8409.,  9435.,  9777.,
                                         13539., 13881., 14907., 15249.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x4x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1564.,  1616.,  2518.,  2608.,  3094.,  3208.,  2060.,  2144.,  3318.,
      3444.,  4983.,  5190.,  5631.,  5874.,  3582.,  3756.,  5238.,  5460.,
      7575.,  7926.,  8223.,  8610.,  5118.,  5388.,  2732.,  2912.,  3742.,
      4024.,  4030.,  4336.,  2332.,  2544.,  8220.,  8528.,  11734., 12208.,
      12310., 12808., 7692.,  8032.,  10998., 11508., 15351., 16134., 15999.,
      16818., 9726.,  10284., 12918., 13524., 17943., 18870., 18591., 19554.,
      11262., 11916., 6316.,  6752.,  8350.,  9016.,  8638.,  9328.,  4892.,
      5360.,  14876., 15440., 20950., 21808., 21526., 22408., 13324., 13920.,
      18678., 19572., 25719., 27078., 26367., 27762., 15870., 16812., 20598.,
      21588., 28311., 29814., 28959., 30498., 17406., 18444., 9900.,  10592.,
      12958., 14008., 13246., 14320., 7452.,  8176.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x4x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4983.,  5190.,  5631.,  5874.,  7575.,  7926.,  8223.,  8610.,
      15351., 16134., 15999., 16818., 17943., 18870., 18591., 19554.,
      25719., 27078., 26367., 27762., 28311., 29814., 28959., 30498.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x4x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3076.,  3128.,  3180.,  3232.,  4946.,  5036.,  5126.,  5216.,  6074.,
      6188.,  6302.,  6416.,  4036.,  4120.,  4204.,  4288.,  6510.,  6636.,
      6762.,  6888.,  9759.,  9966.,  10173., 10380., 11019., 11262., 11505.,
      11748., 6990.,  7164.,  7338.,  7512.,  10254., 10476., 10698., 10920.,
      14799., 15150., 15501., 15852., 16059., 16446., 16833., 17220., 9966.,
      10236., 10506., 10776., 5284.,  5464.,  5644.,  5824.,  7202.,  7484.,
      7766.,  8048.,  7754.,  8060.,  8366.,  8672.,  4452.,  4664.,  4876.,
      5088.,  16132., 16440., 16748., 17056., 22994., 23468., 23942., 24416.,
      24122., 24620., 25118., 25616., 15044., 15384., 15724., 16064., 21486.,
      21996., 22506., 23016., 29919., 30702., 31485., 32268., 31179., 31998.,
      32817., 33636., 18894., 19452., 20010., 20568., 25230., 25836., 26442.,
      27048., 34959., 35886., 36813., 37740., 36219., 37182., 38145., 39108.,
      21870., 22524., 23178., 23832., 12196., 12632., 13068., 13504., 16034.,
      16700., 17366., 18032., 16586., 17276., 17966., 18656., 9316.,  9784.,
      10252., 10720., 29188., 29752., 30316., 30880., 41042., 41900., 42758.,
      43616., 42170., 43052., 43934., 44816., 26052., 26648., 27244., 27840.,
      36462., 37356., 38250., 39144., 50079., 51438., 52797., 54156., 51339.,
      52734., 54129., 55524., 30798., 31740., 32682., 33624., 40206., 41196.,
      42186., 43176., 55119., 56622., 58125., 59628., 56379., 57918., 59457.,
      60996., 33774., 34812., 35850., 36888., 19108., 19800., 20492., 21184.,
      24866., 25916., 26966., 28016., 25418., 26492., 27566., 28640., 14180.,
      14904., 15628., 16352.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x4x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      9759.,  9966.,  10173., 10380., 11019., 11262., 11505., 11748.,
      14799., 15150., 15501., 15852., 16059., 16446., 16833., 17220.,
      29919., 30702., 31485., 32268., 31179., 31998., 32817., 33636.,
      34959., 35886., 36813., 37740., 36219., 37182., 38145., 39108.,
      50079., 51438., 52797., 54156., 51339., 52734., 54129., 55524.,
      55119., 56622., 58125., 59628., 56379., 57918., 59457., 60996.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x4x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6152.,  9964.,   12316.,  8232.,  13284., 20022.,  22686.,  14484.,
      21156., 30678.,  33342.,  20820., 11176., 15388.,  16588.,  9672.,
      33288., 47596.,  49948.,  31272., 44772., 62646.,  65310.,  39828.,
      52644., 73302.,  75966.,  46164., 26024., 34588.,  35788.,  20424.,
      60424., 85228.,  87580.,  54312., 76260., 105270., 107934., 65172.,
      84132., 115926., 118590., 71508., 40872., 53788.,  54988.,  31176.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x4x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {20022.,  22686.,  30678.,  33342.,
                                         62646.,  65310.,  73302.,  75966.,
                                         105270., 107934., 115926., 118590.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x4x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      12104.,  12304.,  19580.,  19928.,  24188.,  24632.,  16136.,  16464.,
      26076.,  26568.,  39234.,  40044.,  44418.,  45372.,  28284.,  28968.,
      41436.,  42312.,  59970.,  61356.,  65154.,  66684.,  40572.,  41640.,
      21640.,  22352.,  29660.,  30776.,  31964.,  33176.,  18504.,  19344.,
      65352.,  66576.,  93308.,  95192.,  97916.,  99896.,  61192.,  62544.,
      87516.,  89544.,  122178., 125292., 127362., 130620., 77436.,  79656.,
      102876., 105288., 142914., 146604., 148098., 151932., 89724.,  92328.,
      50312.,  52048.,  66524.,  69176.,  68828.,  71576.,  38984.,  40848.,
      118600., 120848., 167036., 170456., 171644., 175160., 106248., 108624.,
      148956., 152520., 205122., 210540., 210306., 215868., 126588., 130344.,
      164316., 168264., 225858., 231852., 231042., 237180., 138876., 143016.,
      78984.,  81744.,  103388., 107576., 105692., 109976., 59464.,  62352.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x4x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      39234.,  40044.,  44418.,  45372.,  59970.,  61356.,  65154.,  66684.,
      122178., 125292., 127362., 130620., 142914., 146604., 148098., 151932.,
      205122., 210540., 210306., 215868., 225858., 231852., 231042., 237180.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x4x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      24008.,  24208.,  24408.,  24608.,  38812.,  39160.,  39508.,  39856.,
      47932.,  48376.,  48820.,  49264.,  31944.,  32272.,  32600.,  32928.,
      51660.,  52152.,  52644.,  53136.,  77658.,  78468.,  79278.,  80088.,
      87882.,  88836.,  89790.,  90744.,  55884.,  56568.,  57252.,  57936.,
      81996.,  82872.,  83748.,  84624.,  118554., 119940., 121326., 122712.,
      128778., 130308., 131838., 133368., 80076.,  81144.,  82212.,  83280.,
      42568.,  43280.,  43992.,  44704.,  58204.,  59320.,  60436.,  61552.,
      62716.,  63928.,  65140.,  66352.,  36168.,  37008.,  37848.,  38688.,
      129480., 130704., 131928., 133152., 184732., 186616., 188500., 190384.,
      193852., 195832., 197812., 199792., 121032., 122384., 123736., 125088.,
      173004., 175032., 177060., 179088., 241242., 244356., 247470., 250584.,
      251466., 254724., 257982., 261240., 152652., 154872., 157092., 159312.,
      203340., 205752., 208164., 210576., 282138., 285828., 289518., 293208.,
      292362., 296196., 300030., 303864., 176844., 179448., 182052., 184656.,
      98888.,  100624., 102360., 104096., 130396., 133048., 135700., 138352.,
      134908., 137656., 140404., 143152., 76104.,  77968.,  79832.,  81696.,
      234952., 237200., 239448., 241696., 330652., 334072., 337492., 340912.,
      339772., 343288., 346804., 350320., 210120., 212496., 214872., 217248.,
      294348., 297912., 301476., 305040., 404826., 410244., 415662., 421080.,
      415050., 420612., 426174., 431736., 249420., 253176., 256932., 260688.,
      324684., 328632., 332580., 336528., 445722., 451716., 457710., 463704.,
      455946., 462084., 468222., 474360., 273612., 277752., 281892., 286032.,
      155208., 157968., 160728., 163488., 202588., 206776., 210964., 215152.,
      207100., 211384., 215668., 219952., 116040., 118928., 121816., 124704.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x4x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      77658.,  78468.,  79278.,  80088.,  87882.,  88836.,  89790.,  90744.,
      118554., 119940., 121326., 122712., 128778., 130308., 131838., 133368.,
      241242., 244356., 247470., 250584., 251466., 254724., 257982., 261240.,
      282138., 285828., 289518., 293208., 292362., 296196., 300030., 303864.,
      404826., 410244., 415662., 421080., 415050., 420612., 426174., 431736.,
      445722., 451716., 457710., 463704., 455946., 462084., 468222., 474360.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x4x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      128.,  202.,  241.,  280.,  184.,  276.,  411.,  456.,  501.,  318.,
      441.,  636.,  681.,  726.,  453.,  240.,  331.,  352.,  373.,  220.,
      688.,  982.,  1021., 1060., 664.,  936.,  1311., 1356., 1401., 858.,
      1101., 1536., 1581., 1626., 993.,  560.,  751.,  772.,  793.,  460.,
      1248., 1762., 1801., 1840., 1144., 1596., 2211., 2256., 2301., 1398.,
      1761., 2436., 2481., 2526., 1533., 880.,  1171., 1192., 1213., 700.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x4x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      411.,  456.,  501.,  636.,  681.,  726.,  1311., 1356., 1401.,
      1536., 1581., 1626., 2211., 2256., 2301., 2436., 2481., 2526.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x4x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      240.,  256.,  377.,  404.,  449.,  482.,  521.,  560.,  340.,  368.,
      513.,  552.,  759.,  822.,  840.,  912.,  921.,  1002., 579.,  636.,
      813.,  882.,  1164., 1272., 1245., 1362., 1326., 1452., 819.,  906.,
      424.,  480.,  575.,  662.,  611.,  704.,  647.,  746.,  372.,  440.,
      1280., 1376., 1817., 1964., 1889., 2042., 1961., 2120., 1220., 1328.,
      1713., 1872., 2379., 2622., 2460., 2712., 2541., 2802., 1539., 1716.,
      2013., 2202., 2784., 3072., 2865., 3162., 2946., 3252., 1779., 1986.,
      984.,  1120., 1295., 1502., 1331., 1544., 1367., 1586., 772.,  920.,
      2320., 2496., 3257., 3524., 3329., 3602., 3401., 3680., 2100., 2288.,
      2913., 3192., 3999., 4422., 4080., 4512., 4161., 4602., 2499., 2796.,
      3213., 3522., 4404., 4872., 4485., 4962., 4566., 5052., 2739., 3066.,
      1544., 1760., 2015., 2342., 2051., 2384., 2087., 2426., 1172., 1400.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x4x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      759.,  822.,  840.,  912.,  921.,  1002., 1164., 1272., 1245.,
      1362., 1326., 1452., 2379., 2622., 2460., 2712., 2541., 2802.,
      2784., 3072., 2865., 3162., 2946., 3252., 3999., 4422., 4080.,
      4512., 4161., 4602., 4404., 4872., 4485., 4962., 4566., 5052.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x4x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      464.,  480.,  496.,  512.,  727.,  754.,   781.,  808.,  865.,  898.,
      931.,  964.,  1003., 1042., 1081., 1120.,  652.,  680.,  708.,  736.,
      987.,  1026., 1065., 1104., 1455., 1518.,  1581., 1644., 1608., 1680.,
      1752., 1824., 1761., 1842., 1923., 2004.,  1101., 1158., 1215., 1272.,
      1557., 1626., 1695., 1764., 2220., 2328.,  2436., 2544., 2373., 2490.,
      2607., 2724., 2526., 2652., 2778., 2904.,  1551., 1638., 1725., 1812.,
      792.,  848.,  904.,  960.,  1063., 1150.,  1237., 1324., 1129., 1222.,
      1315., 1408., 1195., 1294., 1393., 1492.,  676.,  744.,  812.,  880.,
      2464., 2560., 2656., 2752., 3487., 3634.,  3781., 3928., 3625., 3778.,
      3931., 4084., 3763., 3922., 4081., 4240.,  2332., 2440., 2548., 2656.,
      3267., 3426., 3585., 3744., 4515., 4758.,  5001., 5244., 4668., 4920.,
      5172., 5424., 4821., 5082., 5343., 5604.,  2901., 3078., 3255., 3432.,
      3837., 4026., 4215., 4404., 5280., 5568.,  5856., 6144., 5433., 5730.,
      6027., 6324., 5586., 5892., 6198., 6504.,  3351., 3558., 3765., 3972.,
      1832., 1968., 2104., 2240., 2383., 2590.,  2797., 3004., 2449., 2662.,
      2875., 3088., 2515., 2734., 2953., 3172.,  1396., 1544., 1692., 1840.,
      4464., 4640., 4816., 4992., 6247., 6514.,  6781., 7048., 6385., 6658.,
      6931., 7204., 6523., 6802., 7081., 7360.,  4012., 4200., 4388., 4576.,
      5547., 5826., 6105., 6384., 7575., 7998.,  8421., 8844., 7728., 8160.,
      8592., 9024., 7881., 8322., 8763., 9204.,  4701., 4998., 5295., 5592.,
      6117., 6426., 6735., 7044., 8340., 8808.,  9276., 9744., 8493., 8970.,
      9447., 9924., 8646., 9132., 9618., 10104., 5151., 5478., 5805., 6132.,
      2872., 3088., 3304., 3520., 3703., 4030.,  4357., 4684., 3769., 4102.,
      4435., 4768., 3835., 4174., 4513., 4852.,  2116., 2344., 2572., 2800.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x4x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1455., 1518., 1581., 1644., 1608., 1680., 1752., 1824., 1761.,
      1842., 1923., 2004., 2220., 2328., 2436., 2544., 2373., 2490.,
      2607., 2724., 2526., 2652., 2778., 2904., 4515., 4758., 5001.,
      5244., 4668., 4920., 5172., 5424., 4821., 5082., 5343., 5604.,
      5280., 5568., 5856., 6144., 5433., 5730., 6027., 6324., 5586.,
      5892., 6198., 6504., 7575., 7998., 8421., 8844., 7728., 8160.,
      8592., 9024., 7881., 8322., 8763., 9204., 8340., 8808., 9276.,
      9744., 8493., 8970., 9447., 9924., 8646., 9132., 9618., 10104.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x4x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      940.,   1490.,  1790.,  2090.,  1372.,  2070.,  3081.,  3423.,  3765.,
      2382.,  3330.,  4791.,  5133.,  5475.,  3402.,  1780.,  2438.,  2594.,
      2750.,  1604.,  5260.,  7490.,  7790.,  8090.,  5052.,  7110.,  9921.,
      10263., 10605., 6462.,  8370.,  11631., 11973., 12315., 7482.,  4180.,
      5558.,  5714.,  5870.,  3364.,  9580.,  13490., 13790., 14090., 8732.,
      12150., 16761., 17103., 17445., 10542., 13410., 18471., 18813., 19155.,
      11562., 6580.,  8678.,  8834.,  8990.,  5124.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x4x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3081.,  3423.,  3765.,  4791.,  5133.,  5475.,  9921.,  10263., 10605.,
      11631., 11973., 12315., 16761., 17103., 17445., 18471., 18813., 19155.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x4x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1820.,  1880.,  2878.,  2980.,  3454.,  3580.,  4030.,  4180.,  2636.,
      2744.,  3990.,  4140.,  5919.,  6162.,  6567.,  6846.,  7215.,  7530.,
      4542.,  4764.,  6390.,  6660.,  9159.,  9582.,  9807.,  10266., 10455.,
      10950., 6462.,  6804.,  3340.,  3560.,  4534.,  4876.,  4822.,  5188.,
      5110.,  5500.,  2940.,  3208.,  10140., 10520., 14398., 14980., 14974.,
      15580., 15550., 16180., 9676.,  10104., 13590., 14220., 18879., 19842.,
      19527., 20526., 20175., 21210., 12222., 12924., 15990., 16740., 22119.,
      23262., 22767., 23946., 23415., 24630., 14142., 14964., 7820.,  8360.,
      10294., 11116., 10582., 11428., 10870., 11740., 6140.,  6728.,  18460.,
      19160., 25918., 26980., 26494., 27580., 27070., 28180., 16716., 17464.,
      23190., 24300., 31839., 33522., 32487., 34206., 33135., 34890., 19902.,
      21084., 25590., 26820., 35079., 36942., 35727., 37626., 36375., 38310.,
      21822., 23124., 12300., 13160., 16054., 17356., 16342., 17668., 16630.,
      17980., 9340.,  10248.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x4x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5919.,  6162.,  6567.,  6846.,  7215.,  7530.,  9159.,  9582.,  9807.,
      10266., 10455., 10950., 18879., 19842., 19527., 20526., 20175., 21210.,
      22119., 23262., 22767., 23946., 23415., 24630., 31839., 33522., 32487.,
      34206., 33135., 34890., 35079., 36942., 35727., 37626., 36375., 38310.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x4x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3580.,  3640.,  3700.,  3760.,  5654.,  5756.,  5858.,  5960.,  6782.,
      6908.,  7034.,  7160.,  7910.,  8060.,  8210.,  8360.,  5164.,  5272.,
      5380.,  5488.,  7830.,  7980.,  8130.,  8280.,  11595., 11838., 12081.,
      12324., 12855., 13134., 13413., 13692., 14115., 14430., 14745., 15060.,
      8862.,  9084.,  9306.,  9528.,  12510., 12780., 13050., 13320., 17895.,
      18318., 18741., 19164., 19155., 19614., 20073., 20532., 20415., 20910.,
      21405., 21900., 12582., 12924., 13266., 13608., 6460.,  6680.,  6900.,
      7120.,  8726.,  9068.,  9410.,  9752.,  9278.,  9644.,  10010., 10376.,
      9830.,  10220., 10610., 11000., 5612.,  5880.,  6148.,  6416.,  19900.,
      20280., 20660., 21040., 28214., 28796., 29378., 29960., 29342., 29948.,
      30554., 31160., 30470., 31100., 31730., 32360., 18924., 19352., 19780.,
      20208., 26550., 27180., 27810., 28440., 36795., 37758., 38721., 39684.,
      38055., 39054., 40053., 41052., 39315., 40350., 41385., 42420., 23742.,
      24444., 25146., 25848., 31230., 31980., 32730., 33480., 43095., 44238.,
      45381., 46524., 44355., 45534., 46713., 47892., 45615., 46830., 48045.,
      49260., 27462., 28284., 29106., 29928., 15100., 15640., 16180., 16720.,
      19766., 20588., 21410., 22232., 20318., 21164., 22010., 22856., 20870.,
      21740., 22610., 23480., 11692., 12280., 12868., 13456., 36220., 36920.,
      37620., 38320., 50774., 51836., 52898., 53960., 51902., 52988., 54074.,
      55160., 53030., 54140., 55250., 56360., 32684., 33432., 34180., 34928.,
      45270., 46380., 47490., 48600., 61995., 63678., 65361., 67044., 63255.,
      64974., 66693., 68412., 64515., 66270., 68025., 69780., 38622., 39804.,
      40986., 42168., 49950., 51180., 52410., 53640., 68295., 70158., 72021.,
      73884., 69555., 71454., 73353., 75252., 70815., 72750., 74685., 76620.,
      42342., 43644., 44946., 46248., 23740., 24600., 25460., 26320., 30806.,
      32108., 33410., 34712., 31358., 32684., 34010., 35336., 31910., 33260.,
      34610., 35960., 17772., 18680., 19588., 20496.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x4x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11595., 11838., 12081., 12324., 12855., 13134., 13413., 13692., 14115.,
      14430., 14745., 15060., 17895., 18318., 18741., 19164., 19155., 19614.,
      20073., 20532., 20415., 20910., 21405., 21900., 36795., 37758., 38721.,
      39684., 38055., 39054., 40053., 41052., 39315., 40350., 41385., 42420.,
      43095., 44238., 45381., 46524., 44355., 45534., 46713., 47892., 45615.,
      46830., 48045., 49260., 61995., 63678., 65361., 67044., 63255., 64974.,
      66693., 68412., 64515., 66270., 68025., 69780., 68295., 70158., 72021.,
      73884., 69555., 71454., 73353., 75252., 70815., 72750., 74685., 76620.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x4x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7192.,   11428.,  13780.,  16132.,  10584.,  16020.,  23838.,  26502.,
      29166.,  18420.,  25860.,  37158.,  39822.,  42486.,  26340.,  13688.,
      18676.,  19876.,  21076.,  12216.,  41112.,  58468.,  60820.,  63172.,
      39384.,  55380.,  77118.,  79782.,  82446.,  50100.,  65220.,  90438.,
      93102.,  95766.,  58020.,  32248.,  42676.,  43876.,  45076.,  25656.,
      75032.,  105508., 107860., 110212., 68184.,  94740.,  130398., 133062.,
      135726., 81780.,  104580., 143718., 146382., 149046., 89700.,  50808.,
      66676.,  67876.,  69076.,  39096.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x4x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      23838.,  26502.,  29166.,  37158.,  39822.,  42486.,
      77118.,  79782.,  82446.,  90438.,  93102.,  95766.,
      130398., 133062., 135726., 143718., 146382., 149046.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x4x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      14152.,  14384.,  22460.,  22856.,  27068.,  27560.,  31676.,  32264.,
      20744.,  21168.,  31452.,  32040.,  46722.,  47676.,  51906.,  53004.,
      57090.,  58332.,  35964.,  36840.,  50652.,  51720.,  72642.,  74316.,
      77826.,  79644.,  83010.,  84972.,  51324.,  52680.,  26504.,  27376.,
      35996.,  37352.,  38300.,  39752.,  40604.,  42152.,  23368.,  24432.,
      80712.,  82224.,  114620., 116936., 119228., 121640., 123836., 126344.,
      77064.,  78768.,  108252., 110760., 150402., 154236., 155586., 159564.,
      160770., 164892., 97404.,  100200., 127452., 130440., 176322., 180876.,
      181506., 186204., 186690., 191532., 112764., 116040., 62344.,  64496.,
      82076.,  85352.,  84380.,  87752.,  86684.,  90152.,  48968.,  51312.,
      147272., 150064., 206780., 211016., 211388., 215720., 215996., 220424.,
      133384., 136368., 185052., 189480., 254082., 260796., 259266., 266124.,
      264450., 271452., 158844., 163560., 204252., 209160., 280002., 287436.,
      285186., 292764., 290370., 298092., 174204., 179400., 98184.,  101616.,
      128156., 133352., 130460., 135752., 132764., 138152., 74568.,  78192.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x4x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      46722.,  47676.,  51906.,  53004.,  57090.,  58332.,  72642.,  74316.,
      77826.,  79644.,  83010.,  84972.,  150402., 154236., 155586., 159564.,
      160770., 164892., 176322., 180876., 181506., 186204., 186690., 191532.,
      254082., 260796., 259266., 266124., 264450., 271452., 280002., 287436.,
      285186., 292764., 290370., 298092.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x4x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      28072.,  28304.,  28536.,  28768.,  44524.,  44920.,  45316.,  45712.,
      53644.,  54136.,  54628.,  55120.,  62764.,  63352.,  63940.,  64528.,
      41064.,  41488.,  41912.,  42336.,  62316.,  62904.,  63492.,  64080.,
      92490.,  93444.,  94398.,  95352.,  102714., 103812., 104910., 106008.,
      112938., 114180., 115422., 116664., 71052.,  71928.,  72804.,  73680.,
      100236., 101304., 102372., 103440., 143610., 145284., 146958., 148632.,
      153834., 155652., 157470., 159288., 164058., 166020., 167982., 169944.,
      101292., 102648., 104004., 105360., 52136.,  53008.,  53880.,  54752.,
      70636.,  71992.,  73348.,  74704.,  75148.,  76600.,  78052.,  79504.,
      79660.,  81208.,  82756.,  84304.,  45672.,  46736.,  47800.,  48864.,
      159912., 161424., 162936., 164448., 226924., 229240., 231556., 233872.,
      236044., 238456., 240868., 243280., 245164., 247672., 250180., 252688.,
      152424., 154128., 155832., 157536., 213996., 216504., 219012., 221520.,
      296970., 300804., 304638., 308472., 307194., 311172., 315150., 319128.,
      317418., 321540., 325662., 329784., 192012., 194808., 197604., 200400.,
      251916., 254904., 257892., 260880., 348090., 352644., 357198., 361752.,
      358314., 363012., 367710., 372408., 368538., 373380., 378222., 383064.,
      222252., 225528., 228804., 232080., 122536., 124688., 126840., 128992.,
      160876., 164152., 167428., 170704., 165388., 168760., 172132., 175504.,
      169900., 173368., 176836., 180304., 95592.,  97936.,  100280., 102624.,
      291752., 294544., 297336., 300128., 409324., 413560., 417796., 422032.,
      418444., 422776., 427108., 431440., 427564., 431992., 436420., 440848.,
      263784., 266768., 269752., 272736., 365676., 370104., 374532., 378960.,
      501450., 508164., 514878., 521592., 511674., 518532., 525390., 532248.,
      521898., 528900., 535902., 542904., 312972., 317688., 322404., 327120.,
      403596., 408504., 413412., 418320., 552570., 560004., 567438., 574872.,
      562794., 570372., 577950., 585528., 573018., 580740., 588462., 596184.,
      343212., 348408., 353604., 358800., 192936., 196368., 199800., 203232.,
      251116., 256312., 261508., 266704., 255628., 260920., 266212., 271504.,
      260140., 265528., 270916., 276304., 145512., 149136., 152760., 156384.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x4x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      92490.,  93444.,  94398.,  95352.,  102714., 103812., 104910., 106008.,
      112938., 114180., 115422., 116664., 143610., 145284., 146958., 148632.,
      153834., 155652., 157470., 159288., 164058., 166020., 167982., 169944.,
      296970., 300804., 304638., 308472., 307194., 311172., 315150., 319128.,
      317418., 321540., 325662., 329784., 348090., 352644., 357198., 361752.,
      358314., 363012., 367710., 372408., 368538., 373380., 378222., 383064.,
      501450., 508164., 514878., 521592., 511674., 518532., 525390., 532248.,
      521898., 528900., 535902., 542904., 552570., 560004., 567438., 574872.,
      562794., 570372., 577950., 585528., 573018., 580740., 588462., 596184.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x4x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      145.,  226.,  265.,  304.,  343.,  223.,  321.,  474.,  519.,
      564.,  609.,  384.,  519.,  744.,  789.,  834.,  879.,  546.,
      283.,  388.,  409.,  430.,  451.,  265.,  817.,  1162., 1201.,
      1240., 1279., 799.,  1113., 1554., 1599., 1644., 1689., 1032.,
      1311., 1824., 1869., 1914., 1959., 1194., 667.,  892.,  913.,
      934.,  955.,  553.,  1489., 2098., 2137., 2176., 2215., 1375.,
      1905., 2634., 2679., 2724., 2769., 1680., 2103., 2904., 2949.,
      2994., 3039., 1842., 1051., 1396., 1417., 1438., 1459., 841.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x4x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      474.,  519.,  564.,  609.,  744.,  789.,  834.,  879.,
      1554., 1599., 1644., 1689., 1824., 1869., 1914., 1959.,
      2634., 2679., 2724., 2769., 2904., 2949., 2994., 3039.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x4x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      272.,  290.,  422.,  452.,  494.,  530.,  566.,  608.,  638.,  686.,
      412.,  446.,  597.,  642.,  876.,  948.,  957.,  1038., 1038., 1128.,
      1119., 1218., 699.,  768.,  957.,  1038., 1362., 1488., 1443., 1578.,
      1524., 1668., 1605., 1758., 987.,  1092., 500.,  566.,  674.,  776.,
      710.,  818.,  746.,  860.,  782.,  902.,  448.,  530.,  1520., 1634.,
      2150., 2324., 2222., 2402., 2294., 2480., 2366., 2558., 1468., 1598.,
      2037., 2226., 2820., 3108., 2901., 3198., 2982., 3288., 3063., 3378.,
      1851., 2064., 2397., 2622., 3306., 3648., 3387., 3738., 3468., 3828.,
      3549., 3918., 2139., 2388., 1172., 1334., 1538., 1784., 1574., 1826.,
      1610., 1868., 1646., 1910., 928.,  1106., 2768., 2978., 3878., 4196.,
      3950., 4274., 4022., 4352., 4094., 4430., 2524., 2750., 3477., 3810.,
      4764., 5268., 4845., 5358., 4926., 5448., 5007., 5538., 3003., 3360.,
      3837., 4206., 5250., 5808., 5331., 5898., 5412., 5988., 5493., 6078.,
      3291., 3684., 1844., 2102., 2402., 2792., 2438., 2834., 2474., 2876.,
      2510., 2918., 1408., 1682.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x4x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      876.,  948.,  957.,  1038., 1038., 1128., 1119., 1218., 1362., 1488.,
      1443., 1578., 1524., 1668., 1605., 1758., 2820., 3108., 2901., 3198.,
      2982., 3288., 3063., 3378., 3306., 3648., 3387., 3738., 3468., 3828.,
      3549., 3918., 4764., 5268., 4845., 5358., 4926., 5448., 5007., 5538.,
      5250., 5808., 5331., 5898., 5412., 5988., 5493., 6078.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x4x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      526.,   544.,   562.,   580.,   814.,   844.,   874.,   904.,   952.,
      988.,   1024.,  1060.,  1090.,  1132.,  1174.,  1216.,  1228.,  1276.,
      1324.,  1372.,  790.,   824.,   858.,   892.,   1149.,  1194.,  1239.,
      1284.,  1680.,  1752.,  1824.,  1896.,  1833.,  1914.,  1995.,  2076.,
      1986.,  2076.,  2166.,  2256.,  2139.,  2238.,  2337.,  2436.,  1329.,
      1398.,  1467.,  1536.,  1833.,  1914.,  1995.,  2076.,  2598.,  2724.,
      2850.,  2976.,  2751.,  2886.,  3021.,  3156.,  2904.,  3048.,  3192.,
      3336.,  3057.,  3210.,  3363.,  3516.,  1869.,  1974.,  2079.,  2184.,
      934.,   1000.,  1066.,  1132.,  1246.,  1348.,  1450.,  1552.,  1312.,
      1420.,  1528.,  1636.,  1378.,  1492.,  1606.,  1720.,  1444.,  1564.,
      1684.,  1804.,  814.,   896.,   978.,   1060.,  2926.,  3040.,  3154.,
      3268.,  4126.,  4300.,  4474.,  4648.,  4264.,  4444.,  4624.,  4804.,
      4402.,  4588.,  4774.,  4960.,  4540.,  4732.,  4924.,  5116.,  2806.,
      2936.,  3066.,  3196.,  3885.,  4074.,  4263.,  4452.,  5352.,  5640.,
      5928.,  6216.,  5505.,  5802.,  6099.,  6396.,  5658.,  5964.,  6270.,
      6576.,  5811.,  6126.,  6441.,  6756.,  3489.,  3702.,  3915.,  4128.,
      4569.,  4794.,  5019.,  5244.,  6270.,  6612.,  6954.,  7296.,  6423.,
      6774.,  7125.,  7476.,  6576.,  6936.,  7296.,  7656.,  6729.,  7098.,
      7467.,  7836.,  4029.,  4278.,  4527.,  4776.,  2182.,  2344.,  2506.,
      2668.,  2830.,  3076.,  3322.,  3568.,  2896.,  3148.,  3400.,  3652.,
      2962.,  3220.,  3478.,  3736.,  3028.,  3292.,  3556.,  3820.,  1678.,
      1856.,  2034.,  2212.,  5326.,  5536.,  5746.,  5956.,  7438.,  7756.,
      8074.,  8392.,  7576.,  7900.,  8224.,  8548.,  7714.,  8044.,  8374.,
      8704.,  7852.,  8188.,  8524.,  8860.,  4822.,  5048.,  5274.,  5500.,
      6621.,  6954.,  7287.,  7620.,  9024.,  9528.,  10032., 10536., 9177.,
      9690.,  10203., 10716., 9330.,  9852.,  10374., 10896., 9483.,  10014.,
      10545., 11076., 5649.,  6006.,  6363.,  6720.,  7305.,  7674.,  8043.,
      8412.,  9942.,  10500., 11058., 11616., 10095., 10662., 11229., 11796.,
      10248., 10824., 11400., 11976., 10401., 10986., 11571., 12156., 6189.,
      6582.,  6975.,  7368.,  3430.,  3688.,  3946.,  4204.,  4414.,  4804.,
      5194.,  5584.,  4480.,  4876.,  5272.,  5668.,  4546.,  4948.,  5350.,
      5752.,  4612.,  5020.,  5428.,  5836.,  2542.,  2816.,  3090.,  3364.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x4x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1680.,  1752.,  1824.,  1896.,  1833.,  1914.,  1995.,  2076.,  1986.,
      2076.,  2166.,  2256.,  2139.,  2238.,  2337.,  2436.,  2598.,  2724.,
      2850.,  2976.,  2751.,  2886.,  3021.,  3156.,  2904.,  3048.,  3192.,
      3336.,  3057.,  3210.,  3363.,  3516.,  5352.,  5640.,  5928.,  6216.,
      5505.,  5802.,  6099.,  6396.,  5658.,  5964.,  6270.,  6576.,  5811.,
      6126.,  6441.,  6756.,  6270.,  6612.,  6954.,  7296.,  6423.,  6774.,
      7125.,  7476.,  6576.,  6936.,  7296.,  7656.,  6729.,  7098.,  7467.,
      7836.,  9024.,  9528.,  10032., 10536., 9177.,  9690.,  10203., 10716.,
      9330.,  9852.,  10374., 10896., 9483.,  10014., 10545., 11076., 9942.,
      10500., 11058., 11616., 10095., 10662., 11229., 11796., 10248., 10824.,
      11400., 11976., 10401., 10986., 11571., 12156.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x4x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1072.,  1676.,  1976.,  2276.,  2576.,  1672.,  2418.,  3567.,  3909.,
      4251.,  4593.,  2886.,  3930.,  5619.,  5961.,  6303.,  6645.,  4110.,
      2104.,  2864.,  3020.,  3176.,  3332.,  1936.,  6256.,  8876.,  9176.,
      9476.,  9776.,  6088.,  8466.,  11775., 12117., 12459., 12801., 7782.,
      9978.,  13827., 14169., 14511., 14853., 9006.,  4984.,  6608.,  6764.,
      6920.,  7076.,  4048.,  11440., 16076., 16376., 16676., 16976., 10504.,
      14514., 19983., 20325., 20667., 21009., 12678., 16026., 22035., 22377.,
      22719., 23061., 13902., 7864.,  10352., 10508., 10664., 10820., 6160.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x4x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3567.,  3909.,  4251.,  4593.,  5619.,  5961.,  6303.,  6645.,
      11775., 12117., 12459., 12801., 13827., 14169., 14511., 14853.,
      19983., 20325., 20667., 21009., 22035., 22377., 22719., 23061.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x4x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2076.,  2144.,  3238.,  3352.,  3814.,  3952.,  4390.,  4552.,  4966.,
      5152.,  3212.,  3344.,  4662.,  4836.,  6855.,  7134.,  7503.,  7818.,
      8151.,  8502.,  8799.,  9186.,  5502.,  5772.,  7542.,  7860.,  10743.,
      11238., 11391., 11922., 12039., 12606., 12687., 13290., 7806.,  8220.,
      3948.,  4208.,  5326.,  5728.,  5614.,  6040.,  5902.,  6352.,  6190.,
      6664.,  3548.,  3872.,  12060., 12512., 17062., 17752., 17638., 18352.,
      18214., 18952., 18790., 19552., 11660., 12176., 16182., 16932., 22407.,
      23550., 23055., 24234., 23703., 24918., 24351., 25602., 14718., 15564.,
      19062., 19956., 26295., 27654., 26943., 28338., 27591., 29022., 28239.,
      29706., 17022., 18012., 9324.,  9968.,  12238., 13216., 12526., 13528.,
      12814., 13840., 13102., 14152., 7388.,  8096.,  22044., 22880., 30886.,
      32152., 31462., 32752., 32038., 33352., 32614., 33952., 20108., 21008.,
      27702., 29028., 37959., 39966., 38607., 40650., 39255., 41334., 39903.,
      42018., 23934., 25356., 30582., 32052., 41847., 44070., 42495., 44754.,
      43143., 45438., 43791., 46122., 26238., 27804., 14700., 15728., 19150.,
      20704., 19438., 21016., 19726., 21328., 20014., 21640., 11228., 12320.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x4x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6855.,  7134.,  7503.,  7818.,  8151.,  8502.,  8799.,  9186.,
      10743., 11238., 11391., 11922., 12039., 12606., 12687., 13290.,
      22407., 23550., 23055., 24234., 23703., 24918., 24351., 25602.,
      26295., 27654., 26943., 28338., 27591., 29022., 28239., 29706.,
      37959., 39966., 38607., 40650., 39255., 41334., 39903., 42018.,
      41847., 44070., 42495., 44754., 43143., 45438., 43791., 46122.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x4x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4084.,  4152.,  4220.,  4288.,  6362.,  6476.,  6590.,  6704.,  7490.,
      7628.,  7766.,  7904.,  8618.,  8780.,  8942.,  9104.,  9746.,  9932.,
      10118., 10304., 6292.,  6424.,  6556.,  6688.,  9150.,  9324.,  9498.,
      9672.,  13431., 13710., 13989., 14268., 14691., 15006., 15321., 15636.,
      15951., 16302., 16653., 17004., 17211., 17598., 17985., 18372., 10734.,
      11004., 11274., 11544., 14766., 15084., 15402., 15720., 20991., 21486.,
      21981., 22476., 22251., 22782., 23313., 23844., 23511., 24078., 24645.,
      25212., 24771., 25374., 25977., 26580., 15198., 15612., 16026., 16440.,
      7636.,  7896.,  8156.,  8416.,  10250., 10652., 11054., 11456., 10802.,
      11228., 11654., 12080., 11354., 11804., 12254., 12704., 11906., 12380.,
      12854., 13328., 6772.,  7096.,  7420.,  7744.,  23668., 24120., 24572.,
      25024., 33434., 34124., 34814., 35504., 34562., 35276., 35990., 36704.,
      35690., 36428., 37166., 37904., 36818., 37580., 38342., 39104., 22804.,
      23320., 23836., 24352., 31614., 32364., 33114., 33864., 43671., 44814.,
      45957., 47100., 44931., 46110., 47289., 48468., 46191., 47406., 48621.,
      49836., 47451., 48702., 49953., 51204., 28590., 29436., 30282., 31128.,
      37230., 38124., 39018., 39912., 51231., 52590., 53949., 55308., 52491.,
      53886., 55281., 56676., 53751., 55182., 56613., 58044., 55011., 56478.,
      57945., 59412., 33054., 34044., 35034., 36024., 18004., 18648., 19292.,
      19936., 23498., 24476., 25454., 26432., 24050., 25052., 26054., 27056.,
      24602., 25628., 26654., 27680., 25154., 26204., 27254., 28304., 14068.,
      14776., 15484., 16192., 43252., 44088., 44924., 45760., 60506., 61772.,
      63038., 64304., 61634., 62924., 64214., 65504., 62762., 64076., 65390.,
      66704., 63890., 65228., 66566., 67904., 39316., 40216., 41116., 42016.,
      54078., 55404., 56730., 58056., 73911., 75918., 77925., 79932., 75171.,
      77214., 79257., 81300., 76431., 78510., 80589., 82668., 77691., 79806.,
      81921., 84036., 46446., 47868., 49290., 50712., 59694., 61164., 62634.,
      64104., 81471., 83694., 85917., 88140., 82731., 84990., 87249., 89508.,
      83991., 86286., 88581., 90876., 85251., 87582., 89913., 92244., 50910.,
      52476., 54042., 55608., 28372., 29400., 30428., 31456., 36746., 38300.,
      39854., 41408., 37298., 38876., 40454., 42032., 37850., 39452., 41054.,
      42656., 38402., 40028., 41654., 43280., 21364., 22456., 23548., 24640.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x4x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      13431., 13710., 13989., 14268., 14691., 15006., 15321., 15636., 15951.,
      16302., 16653., 17004., 17211., 17598., 17985., 18372., 20991., 21486.,
      21981., 22476., 22251., 22782., 23313., 23844., 23511., 24078., 24645.,
      25212., 24771., 25374., 25977., 26580., 43671., 44814., 45957., 47100.,
      44931., 46110., 47289., 48468., 46191., 47406., 48621., 49836., 47451.,
      48702., 49953., 51204., 51231., 52590., 53949., 55308., 52491., 53886.,
      55281., 56676., 53751., 55182., 56613., 58044., 55011., 56478., 57945.,
      59412., 73911., 75918., 77925., 79932., 75171., 77214., 79257., 81300.,
      76431., 78510., 80589., 82668., 77691., 79806., 81921., 84036., 81471.,
      83694., 85917., 88140., 82731., 84990., 87249., 89508., 83991., 86286.,
      88581., 90876., 85251., 87582., 89913., 92244.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x4x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8232.,   12892.,  15244.,  17596.,  19948.,  12936.,  18756.,  27654.,
      30318.,  32982.,  35646.,  22356.,  30564.,  43638.,  46302.,  48966.,
      51630.,  31860.,  16200.,  21964.,  23164.,  24364.,  25564.,  14760.,
      48936.,  69340.,  71692.,  74044.,  76396.,  47496.,  65988.,  91590.,
      94254.,  96918.,  99582.,  60372.,  77796.,  107574., 110238., 112902.,
      115566., 69876.,  38472.,  50764.,  51964.,  53164.,  54364.,  30888.,
      89640.,  125788., 128140., 130492., 132844., 82056.,  113220., 155526.,
      158190., 160854., 163518., 98388.,  125028., 171510., 174174., 176838.,
      179502., 107892., 60744.,  79564.,  80764.,  81964.,  83164.,  47016.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x4x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      27654.,  30318.,  32982.,  35646.,  43638.,  46302.,  48966.,  51630.,
      91590.,  94254.,  96918.,  99582.,  107574., 110238., 112902., 115566.,
      155526., 158190., 160854., 163518., 171510., 174174., 176838., 179502.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x4x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      16200.,  16464.,  25340.,  25784.,  29948.,  30488.,  34556.,  35192.,
      39164.,  39896.,  25352.,  25872.,  36828.,  37512.,  54210.,  55308.,
      59394.,  60636.,  64578.,  65964.,  69762.,  71292.,  43644.,  44712.,
      59868.,  61128.,  85314.,  87276.,  90498.,  92604.,  95682.,  97932.,
      100866., 103260., 62076.,  63720.,  31368.,  32400.,  42332.,  43928.,
      44636.,  46328.,  46940.,  48728.,  49244.,  51128.,  28232.,  29520.,
      96072.,  97872.,  135932., 138680., 140540., 143384., 145148., 148088.,
      149756., 152792., 92936.,  94992.,  128988., 131976., 178626., 183180.,
      183810., 188508., 188994., 193836., 194178., 199164., 117372., 120744.,
      152028., 155592., 209730., 215148., 214914., 220476., 220098., 225804.,
      225282., 231132., 135804., 139752., 74376.,  76944.,  97628.,  101528.,
      99932.,  103928., 102236., 106328., 104540., 108728., 58952.,  61776.,
      175944., 179280., 246524., 251576., 251132., 256280., 255740., 260984.,
      260348., 265688., 160520., 164112., 221148., 226440., 303042., 311052.,
      308226., 316380., 313410., 321708., 318594., 327036., 191100., 196776.,
      244188., 250056., 334146., 343020., 339330., 348348., 344514., 353676.,
      349698., 359004., 209532., 215784., 117384., 121488., 152924., 159128.,
      155228., 161528., 157532., 163928., 159836., 166328., 89672.,  94032.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x4x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      54210.,  55308.,  59394.,  60636.,  64578.,  65964.,  69762.,  71292.,
      85314.,  87276.,  90498.,  92604.,  95682.,  97932.,  100866., 103260.,
      178626., 183180., 183810., 188508., 188994., 193836., 194178., 199164.,
      209730., 215148., 214914., 220476., 220098., 225804., 225282., 231132.,
      303042., 311052., 308226., 316380., 313410., 321708., 318594., 327036.,
      334146., 343020., 339330., 348348., 344514., 353676., 349698., 359004.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x4x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      32136.,  32400.,  32664.,  32928.,  50236.,  50680.,  51124.,  51568.,
      59356.,  59896.,  60436.,  60976.,  68476.,  69112.,  69748.,  70384.,
      77596.,  78328.,  79060.,  79792.,  50184.,  50704.,  51224.,  51744.,
      72972.,  73656.,  74340.,  75024.,  107322., 108420., 109518., 110616.,
      117546., 118788., 120030., 121272., 127770., 129156., 130542., 131928.,
      137994., 139524., 141054., 142584., 86220.,  87288.,  88356.,  89424.,
      118476., 119736., 120996., 122256., 168666., 170628., 172590., 174552.,
      178890., 180996., 183102., 185208., 189114., 191364., 193614., 195864.,
      199338., 201732., 204126., 206520., 122508., 124152., 125796., 127440.,
      61704.,  62736.,  63768.,  64800.,  83068.,  84664.,  86260.,  87856.,
      87580.,  89272.,  90964.,  92656.,  92092.,  93880.,  95668.,  97456.,
      96604.,  98488.,  100372., 102256., 55176.,  56464.,  57752.,  59040.,
      190344., 192144., 193944., 195744., 269116., 271864., 274612., 277360.,
      278236., 281080., 283924., 286768., 287356., 290296., 293236., 296176.,
      296476., 299512., 302548., 305584., 183816., 185872., 187928., 189984.,
      254988., 257976., 260964., 263952., 352698., 357252., 361806., 366360.,
      362922., 367620., 372318., 377016., 373146., 377988., 382830., 387672.,
      383370., 388356., 393342., 398328., 231372., 234744., 238116., 241488.,
      300492., 304056., 307620., 311184., 414042., 419460., 424878., 430296.,
      424266., 429828., 435390., 440952., 434490., 440196., 445902., 451608.,
      444714., 450564., 456414., 462264., 267660., 271608., 275556., 279504.,
      146184., 148752., 151320., 153888., 191356., 195256., 199156., 203056.,
      195868., 199864., 203860., 207856., 200380., 204472., 208564., 212656.,
      204892., 209080., 213268., 217456., 115080., 117904., 120728., 123552.,
      348552., 351888., 355224., 358560., 487996., 493048., 498100., 503152.,
      497116., 502264., 507412., 512560., 506236., 511480., 516724., 521968.,
      515356., 520696., 526036., 531376., 317448., 321040., 324632., 328224.,
      437004., 442296., 447588., 452880., 598074., 606084., 614094., 622104.,
      608298., 616452., 624606., 632760., 618522., 626820., 635118., 643416.,
      628746., 637188., 645630., 654072., 376524., 382200., 387876., 393552.,
      482508., 488376., 494244., 500112., 659418., 668292., 677166., 686040.,
      669642., 678660., 687678., 696696., 679866., 689028., 698190., 707352.,
      690090., 699396., 708702., 718008., 412812., 419064., 425316., 431568.,
      230664., 234768., 238872., 242976., 299644., 305848., 312052., 318256.,
      304156., 310456., 316756., 323056., 308668., 315064., 321460., 327856.,
      313180., 319672., 326164., 332656., 174984., 179344., 183704., 188064.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x4x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      107322., 108420., 109518., 110616., 117546., 118788., 120030., 121272.,
      127770., 129156., 130542., 131928., 137994., 139524., 141054., 142584.,
      168666., 170628., 172590., 174552., 178890., 180996., 183102., 185208.,
      189114., 191364., 193614., 195864., 199338., 201732., 204126., 206520.,
      352698., 357252., 361806., 366360., 362922., 367620., 372318., 377016.,
      373146., 377988., 382830., 387672., 383370., 388356., 393342., 398328.,
      414042., 419460., 424878., 430296., 424266., 429828., 435390., 440952.,
      434490., 440196., 445902., 451608., 444714., 450564., 456414., 462264.,
      598074., 606084., 614094., 622104., 608298., 616452., 624606., 632760.,
      618522., 626820., 635118., 643416., 628746., 637188., 645630., 654072.,
      659418., 668292., 677166., 686040., 669642., 678660., 687678., 696696.,
      679866., 689028., 698190., 707352., 690090., 699396., 708702., 718008.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x5x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      111.,  178.,  217.,  145.,  231.,  348.,  393.,  252.,  363.,  528.,
      573.,  360.,  495.,  708.,  753.,  468.,  261.,  358.,  379.,  223.,
      671.,  958.,  997.,  625.,  891.,  1248., 1293., 792.,  1023., 1428.,
      1473., 900.,  1155., 1608., 1653., 1008., 581.,  778.,  799.,  463.,
      1231., 1738., 1777., 1105., 1551., 2148., 2193., 1332., 1683., 2328.,
      2373., 1440., 1815., 2508., 2553., 1548., 901.,  1198., 1219., 703.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x5x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      348.,  393.,  528.,  573.,  708.,  753.,  1248., 1293., 1428.,
      1473., 1608., 1653., 2148., 2193., 2328., 2373., 2508., 2553.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x5x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      208.,  222.,  332.,  356.,  404.,  434.,  268.,  290.,  429.,  462.,
      642.,  696.,  723.,  786.,  459.,  504.,  669.,  726.,  966.,  1056.,
      1047., 1146., 651.,  720.,  909.,  990.,  1290., 1416., 1371., 1506.,
      843.,  936.,  460.,  522.,  620.,  716.,  656.,  758.,  376.,  446.,
      1248., 1342., 1772., 1916., 1844., 1994., 1148., 1250., 1629., 1782.,
      2262., 2496., 2343., 2586., 1419., 1584., 1869., 2046., 2586., 2856.,
      2667., 2946., 1611., 1800., 2109., 2310., 2910., 3216., 2991., 3306.,
      1803., 2016., 1020., 1162., 1340., 1556., 1376., 1598., 776.,  926.,
      2288., 2462., 3212., 3476., 3284., 3554., 2028., 2210., 2829., 3102.,
      3882., 4296., 3963., 4386., 2379., 2664., 3069., 3366., 4206., 4656.,
      4287., 4746., 2571., 2880., 3309., 3630., 4530., 5016., 4611., 5106.,
      2763., 3096., 1580., 1802., 2060., 2396., 2096., 2438., 1176., 1406.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x5x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      642.,  696.,  723.,  786.,  966.,  1056., 1047., 1146., 1290.,
      1416., 1371., 1506., 2262., 2496., 2343., 2586., 2586., 2856.,
      2667., 2946., 2910., 3216., 2991., 3306., 3882., 4296., 3963.,
      4386., 4206., 4656., 4287., 4746., 4530., 5016., 4611., 5106.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x5x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      402.,  416.,  430.,  444.,  640.,  664.,   688.,  712.,  778.,  808.,
      838.,  868.,  514.,  536.,  558.,  580.,   825.,  858.,  891.,  924.,
      1230., 1284., 1338., 1392., 1383., 1446.,  1509., 1572., 873.,  918.,
      963.,  1008., 1281., 1338., 1395., 1452.,  1842., 1932., 2022., 2112.,
      1995., 2094., 2193., 2292., 1233., 1302.,  1371., 1440., 1737., 1818.,
      1899., 1980., 2454., 2580., 2706., 2832.,  2607., 2742., 2877., 3012.,
      1593., 1686., 1779., 1872., 858.,  920.,   982.,  1044., 1144., 1240.,
      1336., 1432., 1210., 1312., 1414., 1516.,  682.,  752.,  822.,  892.,
      2402., 2496., 2590., 2684., 3400., 3544.,  3688., 3832., 3538., 3688.,
      3838., 3988., 2194., 2296., 2398., 2500.,  3105., 3258., 3411., 3564.,
      4290., 4524., 4758., 4992., 4443., 4686.,  4929., 5172., 2673., 2838.,
      3003., 3168., 3561., 3738., 3915., 4092.,  4902., 5172., 5442., 5712.,
      5055., 5334., 5613., 5892., 3033., 3222.,  3411., 3600., 4017., 4218.,
      4419., 4620., 5514., 5820., 6126., 6432.,  5667., 5982., 6297., 6612.,
      3393., 3606., 3819., 4032., 1898., 2040.,  2182., 2324., 2464., 2680.,
      2896., 3112., 2530., 2752., 2974., 3196.,  1402., 1552., 1702., 1852.,
      4402., 4576., 4750., 4924., 6160., 6424.,  6688., 6952., 6298., 6568.,
      6838., 7108., 3874., 4056., 4238., 4420.,  5385., 5658., 5931., 6204.,
      7350., 7764., 8178., 8592., 7503., 7926.,  8349., 8772., 4473., 4758.,
      5043., 5328., 5841., 6138., 6435., 6732.,  7962., 8412., 8862., 9312.,
      8115., 8574., 9033., 9492., 4833., 5142.,  5451., 5760., 6297., 6618.,
      6939., 7260., 8574., 9060., 9546., 10032., 8727., 9222., 9717., 10212.,
      5193., 5526., 5859., 6192., 2938., 3160.,  3382., 3604., 3784., 4120.,
      4456., 4792., 3850., 4192., 4534., 4876.,  2122., 2352., 2582., 2812.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x5x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1230., 1284., 1338., 1392., 1383.,  1446., 1509., 1572., 1842.,
      1932., 2022., 2112., 1995., 2094.,  2193., 2292., 2454., 2580.,
      2706., 2832., 2607., 2742., 2877.,  3012., 4290., 4524., 4758.,
      4992., 4443., 4686., 4929., 5172.,  4902., 5172., 5442., 5712.,
      5055., 5334., 5613., 5892., 5514.,  5820., 6126., 6432., 5667.,
      5982., 6297., 6612., 7350., 7764.,  8178., 8592., 7503., 7926.,
      8349., 8772., 7962., 8412., 8862.,  9312., 8115., 8574., 9033.,
      9492., 8574., 9060., 9546., 10032., 8727., 9222., 9717., 10212.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x5x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      808.,   1304.,  1604.,  1072.,  1722.,  2595.,  2937.,  1878.,  2730.,
      3963.,  4305.,  2694.,  3738.,  5331.,  5673.,  3510.,  1936.,  2636.,
      2792.,  1624.,  5128.,  7304.,  7604.,  4752.,  6762.,  9435.,  9777.,
      5958.,  7770.,  10803., 11145., 6774.,  8778.,  12171., 12513., 7590.,
      4336.,  5756.,  5912.,  3384.,  9448.,  13304., 13604., 8432.,  11802.,
      16275., 16617., 10038., 12810., 17643., 17985., 10854., 13818., 19011.,
      19353., 11670., 6736.,  8876.,  9032.,  5144.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x5x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2595.,  2937.,  3963.,  4305.,  5331.,  5673.,  9435.,  9777.,  10803.,
      11145., 12171., 12513., 16275., 16617., 17643., 17985., 19011., 19353.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x5x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1564.,  1616.,  2518.,  2608.,  3094.,  3208.,  2060.,  2144.,  3318.,
      3444.,  4983.,  5190.,  5631.,  5874.,  3582.,  3756.,  5238.,  5460.,
      7575.,  7926.,  8223.,  8610.,  5118.,  5388.,  7158.,  7476.,  10167.,
      10662., 10815., 11346., 6654.,  7020.,  3628.,  3872.,  4894.,  5272.,
      5182.,  5584.,  2972.,  3248.,  9884.,  10256., 14038., 14608., 14614.,
      15208., 9100.,  9504.,  12918., 13524., 17943., 18870., 18591., 19554.,
      11262., 11916., 14838., 15540., 20535., 21606., 21183., 22290., 12798.,
      13548., 16758., 17556., 23127., 24342., 23775., 25026., 14334., 15180.,
      8108.,  8672.,  10654., 11512., 10942., 11824., 6172.,  6768.,  18204.,
      18896., 25558., 26608., 26134., 27208., 16140., 16864., 22518., 23604.,
      30903., 32550., 31551., 33234., 18942., 20076., 24438., 25620., 33495.,
      35286., 34143., 35970., 20478., 21708., 26358., 27636., 36087., 38022.,
      36735., 38706., 22014., 23340., 12588., 13472., 16414., 17752., 16702.,
      18064., 9372.,  10288.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x5x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4983.,  5190.,  5631.,  5874.,  7575.,  7926.,  8223.,  8610.,  10167.,
      10662., 10815., 11346., 17943., 18870., 18591., 19554., 20535., 21606.,
      21183., 22290., 23127., 24342., 23775., 25026., 30903., 32550., 31551.,
      33234., 33495., 35286., 34143., 35970., 36087., 38022., 36735., 38706.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x5x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3076.,  3128.,  3180.,  3232.,  4946.,  5036.,  5126.,  5216.,  6074.,
      6188.,  6302.,  6416.,  4036.,  4120.,  4204.,  4288.,  6510.,  6636.,
      6762.,  6888.,  9759.,  9966.,  10173., 10380., 11019., 11262., 11505.,
      11748., 6990.,  7164.,  7338.,  7512.,  10254., 10476., 10698., 10920.,
      14799., 15150., 15501., 15852., 16059., 16446., 16833., 17220., 9966.,
      10236., 10506., 10776., 13998., 14316., 14634., 14952., 19839., 20334.,
      20829., 21324., 21099., 21630., 22161., 22692., 12942., 13308., 13674.,
      14040., 7012.,  7256.,  7500.,  7744.,  9410.,  9788.,  10166., 10544.,
      9962.,  10364., 10766., 11168., 5668.,  5944.,  6220.,  6496.,  19396.,
      19768., 20140., 20512., 27506., 28076., 28646., 29216., 28634., 29228.,
      29822., 30416., 17796., 18200., 18604., 19008., 25230., 25836., 26442.,
      27048., 34959., 35886., 36813., 37740., 36219., 37182., 38145., 39108.,
      21870., 22524., 23178., 23832., 28974., 29676., 30378., 31080., 39999.,
      41070., 42141., 43212., 41259., 42366., 43473., 44580., 24846., 25596.,
      26346., 27096., 32718., 33516., 34314., 35112., 45039., 46254., 47469.,
      48684., 46299., 47550., 48801., 50052., 27822., 28668., 29514., 30360.,
      15652., 16216., 16780., 17344., 20450., 21308., 22166., 23024., 21002.,
      21884., 22766., 23648., 11748., 12344., 12940., 13536., 35716., 36408.,
      37100., 37792., 50066., 51116., 52166., 53216., 51194., 52268., 53342.,
      54416., 31556., 32280., 33004., 33728., 43950., 45036., 46122., 47208.,
      60159., 61806., 63453., 65100., 61419., 63102., 64785., 66468., 36750.,
      37884., 39018., 40152., 47694., 48876., 50058., 51240., 65199., 66990.,
      68781., 70572., 66459., 68286., 70113., 71940., 39726., 40956., 42186.,
      43416., 51438., 52716., 53994., 55272., 70239., 72174., 74109., 76044.,
      71499., 73470., 75441., 77412., 42702., 44028., 45354., 46680., 24292.,
      25176., 26060., 26944., 31490., 32828., 34166., 35504., 32042., 33404.,
      34766., 36128., 17828., 18744., 19660., 20576.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x5x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      9759.,  9966.,  10173., 10380., 11019., 11262., 11505., 11748., 14799.,
      15150., 15501., 15852., 16059., 16446., 16833., 17220., 19839., 20334.,
      20829., 21324., 21099., 21630., 22161., 22692., 34959., 35886., 36813.,
      37740., 36219., 37182., 38145., 39108., 39999., 41070., 42141., 43212.,
      41259., 42366., 43473., 44580., 45039., 46254., 47469., 48684., 46299.,
      47550., 48801., 50052., 60159., 61806., 63453., 65100., 61419., 63102.,
      64785., 66468., 65199., 66990., 68781., 70572., 66459., 68286., 70113.,
      71940., 70239., 72174., 74109., 76044., 71499., 73470., 75441., 77412.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x5x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6152.,  9964.,   12316.,  8232.,  13284.,  20022.,  22686.,  14484.,
      21156., 30678.,  33342.,  20820., 29028.,  41334.,  43998.,  27156.,
      14888., 20188.,  21388.,  12360., 40072.,  57004.,  59356.,  37032.,
      52644., 73302.,  75966.,  46164., 60516.,  83958.,  86622.,  52500.,
      68388., 94614.,  97278.,  58836., 33448.,  44188.,  45388.,  25800.,
      73992., 104044., 106396., 65832., 92004.,  126582., 129246., 77844.,
      99876., 137238., 139902., 84180., 107748., 147894., 150558., 90516.,
      52008., 68188.,  69388.,  39240.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x5x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      20022.,  22686.,  30678.,  33342.,  41334.,  43998.,
      73302.,  75966.,  83958.,  86622.,  94614.,  97278.,
      126582., 129246., 137238., 139902., 147894., 150558.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x5x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      12104.,  12304.,  19580.,  19928.,  24188.,  24632.,  16136.,  16464.,
      26076.,  26568.,  39234.,  40044.,  44418.,  45372.,  28284.,  28968.,
      41436.,  42312.,  59970.,  61356.,  65154.,  66684.,  40572.,  41640.,
      56796.,  58056.,  80706.,  82668.,  85890.,  87996.,  52860.,  54312.,
      28808.,  29776.,  38876.,  40376.,  41180.,  42776.,  23624.,  24720.,
      78664.,  80144.,  111740., 114008., 116348., 118712., 72456.,  74064.,
      102876., 105288., 142914., 146604., 148098., 151932., 89724.,  92328.,
      118236., 121032., 163650., 167916., 168834., 173244., 102012., 105000.,
      133596., 136776., 184386., 189228., 189570., 194556., 114300., 117672.,
      64648.,  66896.,  84956.,  88376.,  87260.,  90776.,  49224.,  51600.,
      145224., 147984., 203900., 208088., 208508., 212792., 128776., 131664.,
      179676., 184008., 246594., 253164., 251778., 258492., 151164., 155688.,
      195036., 199752., 267330., 274476., 272514., 279804., 163452., 168360.,
      210396., 215496., 288066., 295788., 293250., 301116., 175740., 181032.,
      100488., 104016., 131036., 136376., 133340., 138776., 74824.,  78480.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x5x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      39234.,  40044.,  44418.,  45372.,  59970.,  61356.,  65154.,  66684.,
      80706.,  82668.,  85890.,  87996.,  142914., 146604., 148098., 151932.,
      163650., 167916., 168834., 173244., 184386., 189228., 189570., 194556.,
      246594., 253164., 251778., 258492., 267330., 274476., 272514., 279804.,
      288066., 295788., 293250., 301116.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x5x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      24008.,  24208.,  24408.,  24608.,  38812.,  39160.,  39508.,  39856.,
      47932.,  48376.,  48820.,  49264.,  31944.,  32272.,  32600.,  32928.,
      51660.,  52152.,  52644.,  53136.,  77658.,  78468.,  79278.,  80088.,
      87882.,  88836.,  89790.,  90744.,  55884.,  56568.,  57252.,  57936.,
      81996.,  82872.,  83748.,  84624.,  118554., 119940., 121326., 122712.,
      128778., 130308., 131838., 133368., 80076.,  81144.,  82212.,  83280.,
      112332., 113592., 114852., 116112., 159450., 161412., 163374., 165336.,
      169674., 171780., 173886., 175992., 104268., 105720., 107172., 108624.,
      56648.,  57616.,  58584.,  59552.,  76252.,  77752.,  79252.,  80752.,
      80764.,  82360.,  83956.,  85552.,  46152.,  47248.,  48344.,  49440.,
      155848., 157328., 158808., 160288., 221212., 223480., 225748., 228016.,
      230332., 232696., 235060., 237424., 143304., 144912., 146520., 148128.,
      203340., 205752., 208164., 210576., 282138., 285828., 289518., 293208.,
      292362., 296196., 300030., 303864., 176844., 179448., 182052., 184656.,
      233676., 236472., 239268., 242064., 323034., 327300., 331566., 335832.,
      333258., 337668., 342078., 346488., 201036., 204024., 207012., 210000.,
      264012., 267192., 270372., 273552., 363930., 368772., 373614., 378456.,
      374154., 379140., 384126., 389112., 225228., 228600., 231972., 235344.,
      127048., 129296., 131544., 133792., 166492., 169912., 173332., 176752.,
      171004., 174520., 178036., 181552., 96072.,  98448.,  100824., 103200.,
      287688., 290448., 293208., 295968., 403612., 407800., 411988., 416176.,
      412732., 417016., 421300., 425584., 254664., 257552., 260440., 263328.,
      355020., 359352., 363684., 368016., 486618., 493188., 499758., 506328.,
      496842., 503556., 510270., 516984., 297804., 302328., 306852., 311376.,
      385356., 390072., 394788., 399504., 527514., 534660., 541806., 548952.,
      537738., 545028., 552318., 559608., 321996., 326904., 331812., 336720.,
      415692., 420792., 425892., 430992., 568410., 576132., 583854., 591576.,
      578634., 586500., 594366., 602232., 346188., 351480., 356772., 362064.,
      197448., 200976., 204504., 208032., 256732., 262072., 267412., 272752.,
      261244., 266680., 272116., 277552., 145992., 149648., 153304., 156960.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x5x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      77658.,  78468.,  79278.,  80088.,  87882.,  88836.,  89790.,  90744.,
      118554., 119940., 121326., 122712., 128778., 130308., 131838., 133368.,
      159450., 161412., 163374., 165336., 169674., 171780., 173886., 175992.,
      282138., 285828., 289518., 293208., 292362., 296196., 300030., 303864.,
      323034., 327300., 331566., 335832., 333258., 337668., 342078., 346488.,
      363930., 368772., 373614., 378456., 374154., 379140., 384126., 389112.,
      486618., 493188., 499758., 506328., 496842., 503556., 510270., 516984.,
      527514., 534660., 541806., 548952., 537738., 545028., 552318., 559608.,
      568410., 576132., 583854., 591576., 578634., 586500., 594366., 602232.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x5x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      128.,  202.,  241.,  280.,  184.,  276.,  411.,  456.,  501.,  318.,
      441.,  636.,  681.,  726.,  453.,  606.,  861.,  906.,  951.,  588.,
      320.,  436.,  457.,  478.,  280.,  828.,  1177., 1216., 1255., 784.,
      1101., 1536., 1581., 1626., 993.,  1266., 1761., 1806., 1851., 1128.,
      1431., 1986., 2031., 2076., 1263., 720.,  961.,  982.,  1003., 580.,
      1528., 2152., 2191., 2230., 1384., 1926., 2661., 2706., 2751., 1668.,
      2091., 2886., 2931., 2976., 1803., 2256., 3111., 3156., 3201., 1938.,
      1120., 1486., 1507., 1528., 880.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x5x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      411.,  456.,  501.,  636.,  681.,  726.,  861.,  906.,  951.,
      1536., 1581., 1626., 1761., 1806., 1851., 1986., 2031., 2076.,
      2661., 2706., 2751., 2886., 2931., 2976., 3111., 3156., 3201.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x5x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      240.,  256.,  377.,  404.,  449.,  482.,  521.,  560.,  340.,  368.,
      513.,  552.,  759.,  822.,  840.,  912.,  921.,  1002., 579.,  636.,
      813.,  882.,  1164., 1272., 1245., 1362., 1326., 1452., 819.,  906.,
      1113., 1212., 1569., 1722., 1650., 1812., 1731., 1902., 1059., 1176.,
      564.,  640.,  755.,  872.,  791.,  914.,  827.,  956.,  472.,  560.,
      1540., 1656., 2177., 2354., 2249., 2432., 2321., 2510., 1440., 1568.,
      2013., 2202., 2784., 3072., 2865., 3162., 2946., 3252., 1779., 1986.,
      2313., 2532., 3189., 3522., 3270., 3612., 3351., 3702., 2019., 2256.,
      2613., 2862., 3594., 3972., 3675., 4062., 3756., 4152., 2259., 2526.,
      1264., 1440., 1655., 1922., 1691., 1964., 1727., 2006., 972.,  1160.,
      2840., 3056., 3977., 4304., 4049., 4382., 4121., 4460., 2540., 2768.,
      3513., 3852., 4809., 5322., 4890., 5412., 4971., 5502., 2979., 3336.,
      3813., 4182., 5214., 5772., 5295., 5862., 5376., 5952., 3219., 3606.,
      4113., 4512., 5619., 6222., 5700., 6312., 5781., 6402., 3459., 3876.,
      1964., 2240., 2555., 2972., 2591., 3014., 2627., 3056., 1472., 1760.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x5x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      759.,  822.,  840.,  912.,  921.,  1002., 1164., 1272., 1245.,
      1362., 1326., 1452., 1569., 1722., 1650., 1812., 1731., 1902.,
      2784., 3072., 2865., 3162., 2946., 3252., 3189., 3522., 3270.,
      3612., 3351., 3702., 3594., 3972., 3675., 4062., 3756., 4152.,
      4809., 5322., 4890., 5412., 4971., 5502., 5214., 5772., 5295.,
      5862., 5376., 5952., 5619., 6222., 5700., 6312., 5781., 6402.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x5x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      464.,   480.,   496.,   512.,   727.,   754.,   781.,   808.,   865.,
      898.,   931.,   964.,   1003.,  1042.,  1081.,  1120.,  652.,   680.,
      708.,   736.,   987.,   1026.,  1065.,  1104.,  1455.,  1518.,  1581.,
      1644.,  1608.,  1680.,  1752.,  1824.,  1761.,  1842.,  1923.,  2004.,
      1101.,  1158.,  1215.,  1272.,  1557.,  1626.,  1695.,  1764.,  2220.,
      2328.,  2436.,  2544.,  2373.,  2490.,  2607.,  2724.,  2526.,  2652.,
      2778.,  2904.,  1551.,  1638.,  1725.,  1812.,  2127.,  2226.,  2325.,
      2424.,  2985.,  3138.,  3291.,  3444.,  3138.,  3300.,  3462.,  3624.,
      3291.,  3462.,  3633.,  3804.,  2001.,  2118.,  2235.,  2352.,  1052.,
      1128.,  1204.,  1280.,  1393.,  1510.,  1627.,  1744.,  1459.,  1582.,
      1705.,  1828.,  1525.,  1654.,  1783.,  1912.,  856.,   944.,   1032.,
      1120.,  2964.,  3080.,  3196.,  3312.,  4177.,  4354.,  4531.,  4708.,
      4315.,  4498.,  4681.,  4864.,  4453.,  4642.,  4831.,  5020.,  2752.,
      2880.,  3008.,  3136.,  3837.,  4026.,  4215.,  4404.,  5280.,  5568.,
      5856.,  6144.,  5433.,  5730.,  6027.,  6324.,  5586.,  5892.,  6198.,
      6504.,  3351.,  3558.,  3765.,  3972.,  4407.,  4626.,  4845.,  5064.,
      6045.,  6378.,  6711.,  7044.,  6198.,  6540.,  6882.,  7224.,  6351.,
      6702.,  7053.,  7404.,  3801.,  4038.,  4275.,  4512.,  4977.,  5226.,
      5475.,  5724.,  6810.,  7188.,  7566.,  7944.,  6963.,  7350.,  7737.,
      8124.,  7116.,  7512.,  7908.,  8304.,  4251.,  4518.,  4785.,  5052.,
      2352.,  2528.,  2704.,  2880.,  3043.,  3310.,  3577.,  3844.,  3109.,
      3382.,  3655.,  3928.,  3175.,  3454.,  3733.,  4012.,  1756.,  1944.,
      2132.,  2320.,  5464.,  5680.,  5896.,  6112.,  7627.,  7954.,  8281.,
      8608.,  7765.,  8098.,  8431.,  8764.,  7903.,  8242.,  8581.,  8920.,
      4852.,  5080.,  5308.,  5536.,  6687.,  7026.,  7365.,  7704.,  9105.,
      9618.,  10131., 10644., 9258.,  9780.,  10302., 10824., 9411.,  9942.,
      10473., 11004., 5601.,  5958.,  6315.,  6672.,  7257.,  7626.,  7995.,
      8364.,  9870.,  10428., 10986., 11544., 10023., 10590., 11157., 11724.,
      10176., 10752., 11328., 11904., 6051.,  6438.,  6825.,  7212.,  7827.,
      8226.,  8625.,  9024.,  10635., 11238., 11841., 12444., 10788., 11400.,
      12012., 12624., 10941., 11562., 12183., 12804., 6501.,  6918.,  7335.,
      7752.,  3652.,  3928.,  4204.,  4480.,  4693.,  5110.,  5527.,  5944.,
      4759.,  5182.,  5605.,  6028.,  4825.,  5254.,  5683.,  6112.,  2656.,
      2944.,  3232.,  3520.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x5x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1455.,  1518.,  1581.,  1644.,  1608.,  1680.,  1752.,  1824.,  1761.,
      1842.,  1923.,  2004.,  2220.,  2328.,  2436.,  2544.,  2373.,  2490.,
      2607.,  2724.,  2526.,  2652.,  2778.,  2904.,  2985.,  3138.,  3291.,
      3444.,  3138.,  3300.,  3462.,  3624.,  3291.,  3462.,  3633.,  3804.,
      5280.,  5568.,  5856.,  6144.,  5433.,  5730.,  6027.,  6324.,  5586.,
      5892.,  6198.,  6504.,  6045.,  6378.,  6711.,  7044.,  6198.,  6540.,
      6882.,  7224.,  6351.,  6702.,  7053.,  7404.,  6810.,  7188.,  7566.,
      7944.,  6963.,  7350.,  7737.,  8124.,  7116.,  7512.,  7908.,  8304.,
      9105.,  9618.,  10131., 10644., 9258.,  9780.,  10302., 10824., 9411.,
      9942.,  10473., 11004., 9870.,  10428., 10986., 11544., 10023., 10590.,
      11157., 11724., 10176., 10752., 11328., 11904., 10635., 11238., 11841.,
      12444., 10788., 11400., 12012., 12624., 10941., 11562., 12183., 12804.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x5x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      940.,   1490.,  1790.,  2090.,  1372.,  2070.,  3081.,  3423.,  3765.,
      2382.,  3330.,  4791.,  5133.,  5475.,  3402.,  4590.,  6501.,  6843.,
      7185.,  4422.,  2380.,  3218.,  3374.,  3530.,  2044.,  6340.,  8990.,
      9290.,  9590.,  5972.,  8370.,  11631., 11973., 12315., 7482.,  9630.,
      13341., 13683., 14025., 8502.,  10890., 15051., 15393., 15735., 9522.,
      5380.,  7118.,  7274.,  7430.,  4244.,  11740., 16490., 16790., 17090.,
      10572., 14670., 20181., 20523., 20865., 12582., 15930., 21891., 22233.,
      22575., 13602., 17190., 23601., 23943., 24285., 14622., 8380.,  11018.,
      11174., 11330., 6444.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x5x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3081.,  3423.,  3765.,  4791.,  5133.,  5475.,  6501.,  6843.,  7185.,
      11631., 11973., 12315., 13341., 13683., 14025., 15051., 15393., 15735.,
      20181., 20523., 20865., 21891., 22233., 22575., 23601., 23943., 24285.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x5x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1820.,  1880.,  2878.,  2980.,  3454.,  3580.,  4030.,  4180.,  2636.,
      2744.,  3990.,  4140.,  5919.,  6162.,  6567.,  6846.,  7215.,  7530.,
      4542.,  4764.,  6390.,  6660.,  9159.,  9582.,  9807.,  10266., 10455.,
      10950., 6462.,  6804.,  8790.,  9180.,  12399., 13002., 13047., 13686.,
      13695., 14370., 8382.,  8844.,  4460.,  4760.,  5974.,  6436.,  6262.,
      6748.,  6550.,  7060.,  3740.,  4088.,  12220., 12680., 17278., 17980.,
      17854., 18580., 18430., 19180., 11436., 11944., 15990., 16740., 22119.,
      23262., 22767., 23946., 23415., 24630., 14142., 14964., 18390., 19260.,
      25359., 26682., 26007., 27366., 26655., 28050., 16062., 17004., 20790.,
      21780., 28599., 30102., 29247., 30786., 29895., 31470., 17982., 19044.,
      10060., 10760., 13174., 14236., 13462., 14548., 13750., 14860., 7740.,
      8488.,  22620., 23480., 31678., 32980., 32254., 33580., 32830., 34180.,
      20236., 21144., 27990., 29340., 38319., 40362., 38967., 41046., 39615.,
      41730., 23742., 25164., 30390., 31860., 41559., 43782., 42207., 44466.,
      42855., 45150., 25662., 27204., 32790., 34380., 44799., 47202., 45447.,
      47886., 46095., 48570., 27582., 29244., 15660., 16760., 20374., 22036.,
      20662., 22348., 20950., 22660., 11740., 12888.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x5x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5919.,  6162.,  6567.,  6846.,  7215.,  7530.,  9159.,  9582.,  9807.,
      10266., 10455., 10950., 12399., 13002., 13047., 13686., 13695., 14370.,
      22119., 23262., 22767., 23946., 23415., 24630., 25359., 26682., 26007.,
      27366., 26655., 28050., 28599., 30102., 29247., 30786., 29895., 31470.,
      38319., 40362., 38967., 41046., 39615., 41730., 41559., 43782., 42207.,
      44466., 42855., 45150., 44799., 47202., 45447., 47886., 46095., 48570.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x5x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3580.,  3640.,  3700.,  3760.,  5654.,  5756.,  5858.,  5960.,  6782.,
      6908.,  7034.,  7160.,  7910.,  8060.,  8210.,  8360.,  5164.,  5272.,
      5380.,  5488.,  7830.,  7980.,  8130.,  8280.,  11595., 11838., 12081.,
      12324., 12855., 13134., 13413., 13692., 14115., 14430., 14745., 15060.,
      8862.,  9084.,  9306.,  9528.,  12510., 12780., 13050., 13320., 17895.,
      18318., 18741., 19164., 19155., 19614., 20073., 20532., 20415., 20910.,
      21405., 21900., 12582., 12924., 13266., 13608., 17190., 17580., 17970.,
      18360., 24195., 24798., 25401., 26004., 25455., 26094., 26733., 27372.,
      26715., 27390., 28065., 28740., 16302., 16764., 17226., 17688., 8620.,
      8920.,  9220.,  9520.,  11486., 11948., 12410., 12872., 12038., 12524.,
      13010., 13496., 12590., 13100., 13610., 14120., 7132.,  7480.,  7828.,
      8176.,  23980., 24440., 24900., 25360., 33854., 34556., 35258., 35960.,
      34982., 35708., 36434., 37160., 36110., 36860., 37610., 38360., 22364.,
      22872., 23380., 23888., 31230., 31980., 32730., 33480., 43095., 44238.,
      45381., 46524., 44355., 45534., 46713., 47892., 45615., 46830., 48045.,
      49260., 27462., 28284., 29106., 29928., 35910., 36780., 37650., 38520.,
      49395., 50718., 52041., 53364., 50655., 52014., 53373., 54732., 51915.,
      53310., 54705., 56100., 31182., 32124., 33066., 34008., 40590., 41580.,
      42570., 43560., 55695., 57198., 58701., 60204., 56955., 58494., 60033.,
      61572., 58215., 59790., 61365., 62940., 34902., 35964., 37026., 38088.,
      19420., 20120., 20820., 21520., 25286., 26348., 27410., 28472., 25838.,
      26924., 28010., 29096., 26390., 27500., 28610., 29720., 14732., 15480.,
      16228., 16976., 44380., 45240., 46100., 46960., 62054., 63356., 64658.,
      65960., 63182., 64508., 65834., 67160., 64310., 65660., 67010., 68360.,
      39564., 40472., 41380., 42288., 54630., 55980., 57330., 58680., 74595.,
      76638., 78681., 80724., 75855., 77934., 80013., 82092., 77115., 79230.,
      81345., 83460., 46062., 47484., 48906., 50328., 59310., 60780., 62250.,
      63720., 80895., 83118., 85341., 87564., 82155., 84414., 86673., 88932.,
      83415., 85710., 88005., 90300., 49782., 51324., 52866., 54408., 63990.,
      65580., 67170., 68760., 87195., 89598., 92001., 94404., 88455., 90894.,
      93333., 95772., 89715., 92190., 94665., 97140., 53502., 55164., 56826.,
      58488., 30220., 31320., 32420., 33520., 39086., 40748., 42410., 44072.,
      39638., 41324., 43010., 44696., 40190., 41900., 43610., 45320., 22332.,
      23480., 24628., 25776.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x5x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11595., 11838., 12081., 12324., 12855., 13134., 13413., 13692., 14115.,
      14430., 14745., 15060., 17895., 18318., 18741., 19164., 19155., 19614.,
      20073., 20532., 20415., 20910., 21405., 21900., 24195., 24798., 25401.,
      26004., 25455., 26094., 26733., 27372., 26715., 27390., 28065., 28740.,
      43095., 44238., 45381., 46524., 44355., 45534., 46713., 47892., 45615.,
      46830., 48045., 49260., 49395., 50718., 52041., 53364., 50655., 52014.,
      53373., 54732., 51915., 53310., 54705., 56100., 55695., 57198., 58701.,
      60204., 56955., 58494., 60033., 61572., 58215., 59790., 61365., 62940.,
      74595., 76638., 78681., 80724., 75855., 77934., 80013., 82092., 77115.,
      79230., 81345., 83460., 80895., 83118., 85341., 87564., 82155., 84414.,
      86673., 88932., 83415., 85710., 88005., 90300., 87195., 89598., 92001.,
      94404., 88455., 90894., 93333., 95772., 89715., 92190., 94665., 97140.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x5x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7192.,   11428.,  13780.,  16132.,  10584.,  16020.,  23838.,  26502.,
      29166.,  18420.,  25860.,  37158.,  39822.,  42486.,  26340.,  35700.,
      50478.,  53142.,  55806.,  34260.,  18328.,  24676.,  25876.,  27076.,
      15576.,  49592.,  70228.,  72580.,  74932.,  46584.,  65220.,  90438.,
      93102.,  95766.,  58020.,  75060.,  103758., 106422., 109086., 65940.,
      84900.,  117078., 119742., 122406., 73860.,  41528.,  54676.,  55876.,
      57076.,  32376.,  91992.,  129028., 131380., 133732., 82584.,  114420.,
      157038., 159702., 162366., 97620.,  124260., 170358., 173022., 175686.,
      105540., 134100., 183678., 186342., 189006., 113460., 64728.,  84676.,
      85876.,  87076.,  49176.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x5x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      23838.,  26502.,  29166.,  37158.,  39822.,  42486.,  50478.,
      53142.,  55806.,  90438.,  93102.,  95766.,  103758., 106422.,
      109086., 117078., 119742., 122406., 157038., 159702., 162366.,
      170358., 173022., 175686., 183678., 186342., 189006.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x5x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      14152.,  14384.,  22460.,  22856.,  27068.,  27560.,  31676.,  32264.,
      20744.,  21168.,  31452.,  32040.,  46722.,  47676.,  51906.,  53004.,
      57090.,  58332.,  35964.,  36840.,  50652.,  51720.,  72642.,  74316.,
      77826.,  79644.,  83010.,  84972.,  51324.,  52680.,  69852.,  71400.,
      98562.,  100956., 103746., 106284., 108930., 111612., 66684.,  68520.,
      35464.,  36656.,  47516.,  49352.,  49820.,  51752.,  52124.,  54152.,
      29768.,  31152.,  97352.,  99184.,  137660., 140456., 142268., 145160.,
      146876., 149864., 91144.,  93168.,  127452., 130440., 176322., 180876.,
      181506., 186204., 186690., 191532., 112764., 116040., 146652., 150120.,
      202242., 207516., 207426., 212844., 212610., 218172., 128124., 131880.,
      165852., 169800., 228162., 234156., 233346., 239484., 238530., 244812.,
      143484., 147720., 80264.,  83056.,  105116., 109352., 107420., 111752.,
      109724., 114152., 61768.,  64752.,  180552., 183984., 252860., 258056.,
      257468., 262760., 262076., 267464., 161544., 165168., 223452., 228840.,
      305922., 314076., 311106., 319404., 316290., 324732., 189564., 195240.,
      242652., 248520., 331842., 340716., 337026., 346044., 342210., 351372.,
      204924., 211080., 261852., 268200., 357762., 367356., 362946., 372684.,
      368130., 378012., 220284., 226920., 125064., 129456., 162716., 169352.,
      165020., 171752., 167324., 174152., 93768.,  98352.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x5x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      46722.,  47676.,  51906.,  53004.,  57090.,  58332.,  72642.,  74316.,
      77826.,  79644.,  83010.,  84972.,  98562.,  100956., 103746., 106284.,
      108930., 111612., 176322., 180876., 181506., 186204., 186690., 191532.,
      202242., 207516., 207426., 212844., 212610., 218172., 228162., 234156.,
      233346., 239484., 238530., 244812., 305922., 314076., 311106., 319404.,
      316290., 324732., 331842., 340716., 337026., 346044., 342210., 351372.,
      357762., 367356., 362946., 372684., 368130., 378012.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x5x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      28072.,  28304.,  28536.,  28768.,  44524.,  44920.,  45316.,  45712.,
      53644.,  54136.,  54628.,  55120.,  62764.,  63352.,  63940.,  64528.,
      41064.,  41488.,  41912.,  42336.,  62316.,  62904.,  63492.,  64080.,
      92490.,  93444.,  94398.,  95352.,  102714., 103812., 104910., 106008.,
      112938., 114180., 115422., 116664., 71052.,  71928.,  72804.,  73680.,
      100236., 101304., 102372., 103440., 143610., 145284., 146958., 148632.,
      153834., 155652., 157470., 159288., 164058., 166020., 167982., 169944.,
      101292., 102648., 104004., 105360., 138156., 139704., 141252., 142800.,
      194730., 197124., 199518., 201912., 204954., 207492., 210030., 212568.,
      215178., 217860., 220542., 223224., 131532., 133368., 135204., 137040.,
      69736.,  70928.,  72120.,  73312.,  93196.,  95032.,  96868.,  98704.,
      97708.,  99640.,  101572., 103504., 102220., 104248., 106276., 108304.,
      58152.,  59536.,  60920.,  62304.,  192872., 194704., 196536., 198368.,
      272524., 275320., 278116., 280912., 281644., 284536., 287428., 290320.,
      290764., 293752., 296740., 299728., 180264., 182288., 184312., 186336.,
      251916., 254904., 257892., 260880., 348090., 352644., 357198., 361752.,
      358314., 363012., 367710., 372408., 368538., 373380., 378222., 383064.,
      222252., 225528., 228804., 232080., 289836., 293304., 296772., 300240.,
      399210., 404484., 409758., 415032., 409434., 414852., 420270., 425688.,
      419658., 425220., 430782., 436344., 252492., 256248., 260004., 263760.,
      327756., 331704., 335652., 339600., 450330., 456324., 462318., 468312.,
      460554., 466692., 472830., 478968., 470778., 477060., 483342., 489624.,
      282732., 286968., 291204., 295440., 157736., 160528., 163320., 166112.,
      205996., 210232., 214468., 218704., 210508., 214840., 219172., 223504.,
      215020., 219448., 223876., 228304., 120552., 123536., 126520., 129504.,
      357672., 361104., 364536., 367968., 500524., 505720., 510916., 516112.,
      509644., 514936., 520228., 525520., 518764., 524152., 529540., 534928.,
      319464., 323088., 326712., 330336., 441516., 446904., 452292., 457680.,
      603690., 611844., 619998., 628152., 613914., 622212., 630510., 638808.,
      624138., 632580., 641022., 649464., 373452., 379128., 384804., 390480.,
      479436., 485304., 491172., 497040., 654810., 663684., 672558., 681432.,
      665034., 674052., 683070., 692088., 675258., 684420., 693582., 702744.,
      403692., 409848., 416004., 422160., 517356., 523704., 530052., 536400.,
      705930., 715524., 725118., 734712., 716154., 725892., 735630., 745368.,
      726378., 736260., 746142., 756024., 433932., 440568., 447204., 453840.,
      245736., 250128., 254520., 258912., 318796., 325432., 332068., 338704.,
      323308., 330040., 336772., 343504., 327820., 334648., 341476., 348304.,
      182952., 187536., 192120., 196704.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x5x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      92490.,  93444.,  94398.,  95352.,  102714., 103812., 104910., 106008.,
      112938., 114180., 115422., 116664., 143610., 145284., 146958., 148632.,
      153834., 155652., 157470., 159288., 164058., 166020., 167982., 169944.,
      194730., 197124., 199518., 201912., 204954., 207492., 210030., 212568.,
      215178., 217860., 220542., 223224., 348090., 352644., 357198., 361752.,
      358314., 363012., 367710., 372408., 368538., 373380., 378222., 383064.,
      399210., 404484., 409758., 415032., 409434., 414852., 420270., 425688.,
      419658., 425220., 430782., 436344., 450330., 456324., 462318., 468312.,
      460554., 466692., 472830., 478968., 470778., 477060., 483342., 489624.,
      603690., 611844., 619998., 628152., 613914., 622212., 630510., 638808.,
      624138., 632580., 641022., 649464., 654810., 663684., 672558., 681432.,
      665034., 674052., 683070., 692088., 675258., 684420., 693582., 702744.,
      705930., 715524., 725118., 734712., 716154., 725892., 735630., 745368.,
      726378., 736260., 746142., 756024.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x5x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      145.,  226.,  265.,  304.,  343.,  223.,  321.,  474.,  519.,  564.,
      609.,  384.,  519.,  744.,  789.,  834.,  879.,  546.,  717.,  1014.,
      1059., 1104., 1149., 708.,  379.,  514.,  535.,  556.,  577.,  337.,
      985.,  1396., 1435., 1474., 1513., 943.,  1311., 1824., 1869., 1914.,
      1959., 1194., 1509., 2094., 2139., 2184., 2229., 1356., 1707., 2364.,
      2409., 2454., 2499., 1518., 859.,  1144., 1165., 1186., 1207., 697.,
      1825., 2566., 2605., 2644., 2683., 1663., 2301., 3174., 3219., 3264.,
      3309., 2004., 2499., 3444., 3489., 3534., 3579., 2166., 2697., 3714.,
      3759., 3804., 3849., 2328., 1339., 1774., 1795., 1816., 1837., 1057.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x5x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      474.,  519.,  564.,  609.,  744.,  789.,  834.,  879.,  1014.,
      1059., 1104., 1149., 1824., 1869., 1914., 1959., 2094., 2139.,
      2184., 2229., 2364., 2409., 2454., 2499., 3174., 3219., 3264.,
      3309., 3444., 3489., 3534., 3579., 3714., 3759., 3804., 3849.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x5x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      272.,  290.,  422.,  452.,  494.,  530.,  566.,  608.,  638.,  686.,
      412.,  446.,  597.,  642.,  876.,  948.,  957.,  1038., 1038., 1128.,
      1119., 1218., 699.,  768.,  957.,  1038., 1362., 1488., 1443., 1578.,
      1524., 1668., 1605., 1758., 987.,  1092., 1317., 1434., 1848., 2028.,
      1929., 2118., 2010., 2208., 2091., 2298., 1275., 1416., 668.,  758.,
      890.,  1028., 926.,  1070., 962.,  1112., 998.,  1154., 568.,  674.,
      1832., 1970., 2582., 2792., 2654., 2870., 2726., 2948., 2798., 3026.,
      1732., 1886., 2397., 2622., 3306., 3648., 3387., 3738., 3468., 3828.,
      3549., 3918., 2139., 2388., 2757., 3018., 3792., 4188., 3873., 4278.,
      3954., 4368., 4035., 4458., 2427., 2712., 3117., 3414., 4278., 4728.,
      4359., 4818., 4440., 4908., 4521., 4998., 2715., 3036., 1508., 1718.,
      1970., 2288., 2006., 2330., 2042., 2372., 2078., 2414., 1168., 1394.,
      3392., 3650., 4742., 5132., 4814., 5210., 4886., 5288., 4958., 5366.,
      3052., 3326., 4197., 4602., 5736., 6348., 5817., 6438., 5898., 6528.,
      5979., 6618., 3579., 4008., 4557., 4998., 6222., 6888., 6303., 6978.,
      6384., 7068., 6465., 7158., 3867., 4332., 4917., 5394., 6708., 7428.,
      6789., 7518., 6870., 7608., 6951., 7698., 4155., 4656., 2348., 2678.,
      3050., 3548., 3086., 3590., 3122., 3632., 3158., 3674., 1768., 2114.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x5x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      876.,  948.,  957.,  1038., 1038., 1128., 1119., 1218., 1362.,
      1488., 1443., 1578., 1524., 1668., 1605., 1758., 1848., 2028.,
      1929., 2118., 2010., 2208., 2091., 2298., 3306., 3648., 3387.,
      3738., 3468., 3828., 3549., 3918., 3792., 4188., 3873., 4278.,
      3954., 4368., 4035., 4458., 4278., 4728., 4359., 4818., 4440.,
      4908., 4521., 4998., 5736., 6348., 5817., 6438., 5898., 6528.,
      5979., 6618., 6222., 6888., 6303., 6978., 6384., 7068., 6465.,
      7158., 6708., 7428., 6789., 7518., 6870., 7608., 6951., 7698.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x5x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      526.,   544.,   562.,   580.,   814.,   844.,   874.,   904.,   952.,
      988.,   1024.,  1060.,  1090.,  1132.,  1174.,  1216.,  1228.,  1276.,
      1324.,  1372.,  790.,   824.,   858.,   892.,   1149.,  1194.,  1239.,
      1284.,  1680.,  1752.,  1824.,  1896.,  1833.,  1914.,  1995.,  2076.,
      1986.,  2076.,  2166.,  2256.,  2139.,  2238.,  2337.,  2436.,  1329.,
      1398.,  1467.,  1536.,  1833.,  1914.,  1995.,  2076.,  2598.,  2724.,
      2850.,  2976.,  2751.,  2886.,  3021.,  3156.,  2904.,  3048.,  3192.,
      3336.,  3057.,  3210.,  3363.,  3516.,  1869.,  1974.,  2079.,  2184.,
      2517.,  2634.,  2751.,  2868.,  3516.,  3696.,  3876.,  4056.,  3669.,
      3858.,  4047.,  4236.,  3822.,  4020.,  4218.,  4416.,  3975.,  4182.,
      4389.,  4596.,  2409.,  2550.,  2691.,  2832.,  1246.,  1336.,  1426.,
      1516.,  1642.,  1780.,  1918.,  2056.,  1708.,  1852.,  1996.,  2140.,
      1774.,  1924.,  2074.,  2224.,  1840.,  1996.,  2152.,  2308.,  1030.,
      1136.,  1242.,  1348.,  3526.,  3664.,  3802.,  3940.,  4954.,  5164.,
      5374.,  5584.,  5092.,  5308.,  5524.,  5740.,  5230.,  5452.,  5674.,
      5896.,  5368.,  5596.,  5824.,  6052.,  3310.,  3464.,  3618.,  3772.,
      4569.,  4794.,  5019.,  5244.,  6270.,  6612.,  6954.,  7296.,  6423.,
      6774.,  7125.,  7476.,  6576.,  6936.,  7296.,  7656.,  6729.,  7098.,
      7467.,  7836.,  4029.,  4278.,  4527.,  4776.,  5253.,  5514.,  5775.,
      6036.,  7188.,  7584.,  7980.,  8376.,  7341.,  7746.,  8151.,  8556.,
      7494.,  7908.,  8322.,  8736.,  7647.,  8070.,  8493.,  8916.,  4569.,
      4854.,  5139.,  5424.,  5937.,  6234.,  6531.,  6828.,  8106.,  8556.,
      9006.,  9456.,  8259.,  8718.,  9177.,  9636.,  8412.,  8880.,  9348.,
      9816.,  8565.,  9042.,  9519.,  9996.,  5109.,  5430.,  5751.,  6072.,
      2806.,  3016.,  3226.,  3436.,  3622.,  3940.,  4258.,  4576.,  3688.,
      4012.,  4336.,  4660.,  3754.,  4084.,  4414.,  4744.,  3820.,  4156.,
      4492.,  4828.,  2110.,  2336.,  2562.,  2788.,  6526.,  6784.,  7042.,
      7300.,  9094.,  9484.,  9874.,  10264., 9232.,  9628.,  10024., 10420.,
      9370.,  9772.,  10174., 10576., 9508.,  9916.,  10324., 10732., 5830.,
      6104.,  6378.,  6652.,  7989.,  8394.,  8799.,  9204.,  10860., 11472.,
      12084., 12696., 11013., 11634., 12255., 12876., 11166., 11796., 12426.,
      13056., 11319., 11958., 12597., 13236., 6729.,  7158.,  7587.,  8016.,
      8673.,  9114.,  9555.,  9996.,  11778., 12444., 13110., 13776., 11931.,
      12606., 13281., 13956., 12084., 12768., 13452., 14136., 12237., 12930.,
      13623., 14316., 7269.,  7734.,  8199.,  8664.,  9357.,  9834.,  10311.,
      10788., 12696., 13416., 14136., 14856., 12849., 13578., 14307., 15036.,
      13002., 13740., 14478., 15216., 13155., 13902., 14649., 15396., 7809.,
      8310.,  8811.,  9312.,  4366.,  4696.,  5026.,  5356.,  5602.,  6100.,
      6598.,  7096.,  5668.,  6172.,  6676.,  7180.,  5734.,  6244.,  6754.,
      7264.,  5800.,  6316.,  6832.,  7348.,  3190.,  3536.,  3882.,  4228.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x5x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1680.,  1752.,  1824.,  1896.,  1833.,  1914.,  1995.,  2076.,  1986.,
      2076.,  2166.,  2256.,  2139.,  2238.,  2337.,  2436.,  2598.,  2724.,
      2850.,  2976.,  2751.,  2886.,  3021.,  3156.,  2904.,  3048.,  3192.,
      3336.,  3057.,  3210.,  3363.,  3516.,  3516.,  3696.,  3876.,  4056.,
      3669.,  3858.,  4047.,  4236.,  3822.,  4020.,  4218.,  4416.,  3975.,
      4182.,  4389.,  4596.,  6270.,  6612.,  6954.,  7296.,  6423.,  6774.,
      7125.,  7476.,  6576.,  6936.,  7296.,  7656.,  6729.,  7098.,  7467.,
      7836.,  7188.,  7584.,  7980.,  8376.,  7341.,  7746.,  8151.,  8556.,
      7494.,  7908.,  8322.,  8736.,  7647.,  8070.,  8493.,  8916.,  8106.,
      8556.,  9006.,  9456.,  8259.,  8718.,  9177.,  9636.,  8412.,  8880.,
      9348.,  9816.,  8565.,  9042.,  9519.,  9996.,  10860., 11472., 12084.,
      12696., 11013., 11634., 12255., 12876., 11166., 11796., 12426., 13056.,
      11319., 11958., 12597., 13236., 11778., 12444., 13110., 13776., 11931.,
      12606., 13281., 13956., 12084., 12768., 13452., 14136., 12237., 12930.,
      13623., 14316., 12696., 13416., 14136., 14856., 12849., 13578., 14307.,
      15036., 13002., 13740., 14478., 15216., 13155., 13902., 14649., 15396.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x5x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1072.,  1676.,  1976.,  2276.,  2576.,  1672.,  2418.,  3567.,  3909.,
      4251.,  4593.,  2886.,  3930.,  5619.,  5961.,  6303.,  6645.,  4110.,
      5442.,  7671.,  8013.,  8355.,  8697.,  5334.,  2824.,  3800.,  3956.,
      4112.,  4268.,  2464.,  7552.,  10676., 10976., 11276., 11576., 7192.,
      9978.,  13827., 14169., 14511., 14853., 9006.,  11490., 15879., 16221.,
      16563., 16905., 10230., 13002., 17931., 18273., 18615., 18957., 11454.,
      6424.,  8480.,  8636.,  8792.,  8948.,  5104.,  14032., 19676., 19976.,
      20276., 20576., 12712., 17538., 24087., 24429., 24771., 25113., 15126.,
      19050., 26139., 26481., 26823., 27165., 16350., 20562., 28191., 28533.,
      28875., 29217., 17574., 10024., 13160., 13316., 13472., 13628., 7744.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x5x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3567.,  3909.,  4251.,  4593.,  5619.,  5961.,  6303.,  6645.,  7671.,
      8013.,  8355.,  8697.,  13827., 14169., 14511., 14853., 15879., 16221.,
      16563., 16905., 17931., 18273., 18615., 18957., 24087., 24429., 24771.,
      25113., 26139., 26481., 26823., 27165., 28191., 28533., 28875., 29217.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x5x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2076.,  2144.,  3238.,  3352.,  3814.,  3952.,  4390.,  4552.,  4966.,
      5152.,  3212.,  3344.,  4662.,  4836.,  6855.,  7134.,  7503.,  7818.,
      8151.,  8502.,  8799.,  9186.,  5502.,  5772.,  7542.,  7860.,  10743.,
      11238., 11391., 11922., 12039., 12606., 12687., 13290., 7806.,  8220.,
      10422., 10884., 14631., 15342., 15279., 16026., 15927., 16710., 16575.,
      17394., 10110., 10668., 5292.,  5648.,  7054.,  7600.,  7342.,  7912.,
      7630.,  8224.,  7918.,  8536.,  4508.,  4928.,  14556., 15104., 20518.,
      21352., 21094., 21952., 21670., 22552., 22246., 23152., 13772., 14384.,
      19062., 19956., 26295., 27654., 26943., 28338., 27591., 29022., 28239.,
      29706., 17022., 18012., 21942., 22980., 30183., 31758., 30831., 32442.,
      31479., 33126., 32127., 33810., 19326., 20460., 24822., 26004., 34071.,
      35862., 34719., 36546., 35367., 37230., 36015., 37914., 21630., 22908.,
      12012., 12848., 15694., 16960., 15982., 17272., 16270., 17584., 16558.,
      17896., 9308.,  10208., 27036., 28064., 37798., 39352., 38374., 39952.,
      38950., 40552., 39526., 41152., 24332., 25424., 33462., 35076., 45735.,
      48174., 46383., 48858., 47031., 49542., 47679., 50226., 28542., 30252.,
      36342., 38100., 49623., 52278., 50271., 52962., 50919., 53646., 51567.,
      54330., 30846., 32700., 39222., 41124., 53511., 56382., 54159., 57066.,
      54807., 57750., 55455., 58434., 33150., 35148., 18732., 20048., 24334.,
      26320., 24622., 26632., 24910., 26944., 25198., 27256., 14108., 15488.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x5x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6855.,  7134.,  7503.,  7818.,  8151.,  8502.,  8799.,  9186.,  10743.,
      11238., 11391., 11922., 12039., 12606., 12687., 13290., 14631., 15342.,
      15279., 16026., 15927., 16710., 16575., 17394., 26295., 27654., 26943.,
      28338., 27591., 29022., 28239., 29706., 30183., 31758., 30831., 32442.,
      31479., 33126., 32127., 33810., 34071., 35862., 34719., 36546., 35367.,
      37230., 36015., 37914., 45735., 48174., 46383., 48858., 47031., 49542.,
      47679., 50226., 49623., 52278., 50271., 52962., 50919., 53646., 51567.,
      54330., 53511., 56382., 54159., 57066., 54807., 57750., 55455., 58434.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x5x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4084.,   4152.,   4220.,   4288.,   6362.,   6476.,   6590.,   6704.,
      7490.,   7628.,   7766.,   7904.,   8618.,   8780.,   8942.,   9104.,
      9746.,   9932.,   10118.,  10304.,  6292.,   6424.,   6556.,   6688.,
      9150.,   9324.,   9498.,   9672.,   13431.,  13710.,  13989.,  14268.,
      14691.,  15006.,  15321.,  15636.,  15951.,  16302.,  16653.,  17004.,
      17211.,  17598.,  17985.,  18372.,  10734.,  11004.,  11274.,  11544.,
      14766.,  15084.,  15402.,  15720.,  20991.,  21486.,  21981.,  22476.,
      22251.,  22782.,  23313.,  23844.,  23511.,  24078.,  24645.,  25212.,
      24771.,  25374.,  25977.,  26580.,  15198.,  15612.,  16026.,  16440.,
      20382.,  20844.,  21306.,  21768.,  28551.,  29262.,  29973.,  30684.,
      29811.,  30558.,  31305.,  32052.,  31071.,  31854.,  32637.,  33420.,
      32331.,  33150.,  33969.,  34788.,  19662.,  20220.,  20778.,  21336.,
      10228.,  10584.,  10940.,  11296.,  13562.,  14108.,  14654.,  15200.,
      14114.,  14684.,  15254.,  15824.,  14666.,  15260.,  15854.,  16448.,
      15218.,  15836.,  16454.,  17072.,  8596.,   9016.,   9436.,   9856.,
      28564.,  29112.,  29660.,  30208.,  40202.,  41036.,  41870.,  42704.,
      41330.,  42188.,  43046.,  43904.,  42458.,  43340.,  44222.,  45104.,
      43586.,  44492.,  45398.,  46304.,  26932.,  27544.,  28156.,  28768.,
      37230.,  38124.,  39018.,  39912.,  51231.,  52590.,  53949.,  55308.,
      52491.,  53886.,  55281.,  56676.,  53751.,  55182.,  56613.,  58044.,
      55011.,  56478.,  57945.,  59412.,  33054.,  34044.,  35034.,  36024.,
      42846.,  43884.,  44922.,  45960.,  58791.,  60366.,  61941.,  63516.,
      60051.,  61662.,  63273.,  64884.,  61311.,  62958.,  64605.,  66252.,
      62571.,  64254.,  65937.,  67620.,  37518.,  38652.,  39786.,  40920.,
      48462.,  49644.,  50826.,  52008.,  66351.,  68142.,  69933.,  71724.,
      67611.,  69438.,  71265.,  73092.,  68871.,  70734.,  72597.,  74460.,
      70131.,  72030.,  73929.,  75828.,  41982.,  43260.,  44538.,  45816.,
      23188.,  24024.,  24860.,  25696.,  30122.,  31388.,  32654.,  33920.,
      30674.,  31964.,  33254.,  34544.,  31226.,  32540.,  33854.,  35168.,
      31778.,  33116.,  34454.,  35792.,  17716.,  18616.,  19516.,  20416.,
      53044.,  54072.,  55100.,  56128.,  74042.,  75596.,  77150.,  78704.,
      75170.,  76748.,  78326.,  79904.,  76298.,  77900.,  79502.,  81104.,
      77426.,  79052.,  80678.,  82304.,  47572.,  48664.,  49756.,  50848.,
      65310.,  66924.,  68538.,  70152.,  89031.,  91470.,  93909.,  96348.,
      90291.,  92766.,  95241.,  97716.,  91551.,  94062.,  96573.,  99084.,
      92811.,  95358.,  97905.,  100452., 55374.,  57084.,  58794.,  60504.,
      70926.,  72684.,  74442.,  76200.,  96591.,  99246.,  101901., 104556.,
      97851.,  100542., 103233., 105924., 99111.,  101838., 104565., 107292.,
      100371., 103134., 105897., 108660., 59838.,  61692.,  63546.,  65400.,
      76542.,  78444.,  80346.,  82248.,  104151., 107022., 109893., 112764.,
      105411., 108318., 111225., 114132., 106671., 109614., 112557., 115500.,
      107931., 110910., 113889., 116868., 64302.,  66300.,  68298.,  70296.,
      36148.,  37464.,  38780.,  40096.,  46682.,  48668.,  50654.,  52640.,
      47234.,  49244.,  51254.,  53264.,  47786.,  49820.,  51854.,  53888.,
      48338.,  50396.,  52454.,  54512.,  26836.,  28216.,  29596.,  30976.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x5x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      13431.,  13710.,  13989.,  14268.,  14691.,  15006.,  15321.,  15636.,
      15951.,  16302.,  16653.,  17004.,  17211.,  17598.,  17985.,  18372.,
      20991.,  21486.,  21981.,  22476.,  22251.,  22782.,  23313.,  23844.,
      23511.,  24078.,  24645.,  25212.,  24771.,  25374.,  25977.,  26580.,
      28551.,  29262.,  29973.,  30684.,  29811.,  30558.,  31305.,  32052.,
      31071.,  31854.,  32637.,  33420.,  32331.,  33150.,  33969.,  34788.,
      51231.,  52590.,  53949.,  55308.,  52491.,  53886.,  55281.,  56676.,
      53751.,  55182.,  56613.,  58044.,  55011.,  56478.,  57945.,  59412.,
      58791.,  60366.,  61941.,  63516.,  60051.,  61662.,  63273.,  64884.,
      61311.,  62958.,  64605.,  66252.,  62571.,  64254.,  65937.,  67620.,
      66351.,  68142.,  69933.,  71724.,  67611.,  69438.,  71265.,  73092.,
      68871.,  70734.,  72597.,  74460.,  70131.,  72030.,  73929.,  75828.,
      89031.,  91470.,  93909.,  96348.,  90291.,  92766.,  95241.,  97716.,
      91551.,  94062.,  96573.,  99084.,  92811.,  95358.,  97905.,  100452.,
      96591.,  99246.,  101901., 104556., 97851.,  100542., 103233., 105924.,
      99111.,  101838., 104565., 107292., 100371., 103134., 105897., 108660.,
      104151., 107022., 109893., 112764., 105411., 108318., 111225., 114132.,
      106671., 109614., 112557., 115500., 107931., 110910., 113889., 116868.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x5x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8232.,   12892.,  15244.,  17596.,  19948.,  12936.,  18756.,  27654.,
      30318.,  32982.,  35646.,  22356.,  30564.,  43638.,  46302.,  48966.,
      51630.,  31860.,  42372.,  59622.,  62286.,  64950.,  67614.,  41364.,
      21768.,  29164.,  30364.,  31564.,  32764.,  18792.,  59112.,  83452.,
      85804.,  88156.,  90508.,  56136.,  77796.,  107574., 110238., 112902.,
      115566., 69876.,  89604.,  123558., 126222., 128886., 131550., 79380.,
      101412., 139542., 142206., 144870., 147534., 88884.,  49608.,  65164.,
      66364.,  67564.,  68764.,  38952.,  109992., 154012., 156364., 158716.,
      161068., 99336.,  136836., 187494., 190158., 192822., 195486., 117396.,
      148644., 203478., 206142., 208806., 211470., 126900., 160452., 219462.,
      222126., 224790., 227454., 136404., 77448.,  101164., 102364., 103564.,
      104764., 59112.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x5x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      27654.,  30318.,  32982.,  35646.,  43638.,  46302.,  48966.,  51630.,
      59622.,  62286.,  64950.,  67614.,  107574., 110238., 112902., 115566.,
      123558., 126222., 128886., 131550., 139542., 142206., 144870., 147534.,
      187494., 190158., 192822., 195486., 203478., 206142., 208806., 211470.,
      219462., 222126., 224790., 227454.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x5x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      16200.,  16464.,  25340.,  25784.,  29948.,  30488.,  34556.,  35192.,
      39164.,  39896.,  25352.,  25872.,  36828.,  37512.,  54210.,  55308.,
      59394.,  60636.,  64578.,  65964.,  69762.,  71292.,  43644.,  44712.,
      59868.,  61128.,  85314.,  87276.,  90498.,  92604.,  95682.,  97932.,
      100866., 103260., 62076.,  63720.,  82908.,  84744.,  116418., 119244.,
      121602., 124572., 126786., 129900., 131970., 135228., 80508.,  82728.,
      42120.,  43536.,  56156.,  58328.,  58460.,  60728.,  60764.,  63128.,
      63068.,  65528.,  35912.,  37584.,  116040., 118224., 163580., 166904.,
      168188., 171608., 172796., 176312., 177404., 181016., 109832., 112272.,
      152028., 155592., 209730., 215148., 214914., 220476., 220098., 225804.,
      225282., 231132., 135804., 139752., 175068., 179208., 240834., 247116.,
      246018., 252444., 251202., 257772., 256386., 263100., 154236., 158760.,
      198108., 202824., 271938., 279084., 277122., 284412., 282306., 289740.,
      287490., 295068., 172668., 177768., 95880.,  99216.,  125276., 130328.,
      127580., 132728., 129884., 135128., 132188., 137528., 74312.,  77904.,
      215880., 219984., 301820., 308024., 306428., 312728., 311036., 317432.,
      315644., 322136., 194312., 198672., 267228., 273672., 365250., 374988.,
      370434., 380316., 375618., 385644., 380802., 390972., 227964., 234792.,
      290268., 297288., 396354., 406956., 401538., 412284., 406722., 417612.,
      411906., 422940., 246396., 253800., 313308., 320904., 427458., 438924.,
      432642., 444252., 437826., 449580., 443010., 454908., 264828., 272808.,
      149640., 154896., 194396., 202328., 196700., 204728., 199004., 207128.,
      201308., 209528., 112712., 118224.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x5x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      54210.,  55308.,  59394.,  60636.,  64578.,  65964.,  69762.,  71292.,
      85314.,  87276.,  90498.,  92604.,  95682.,  97932.,  100866., 103260.,
      116418., 119244., 121602., 124572., 126786., 129900., 131970., 135228.,
      209730., 215148., 214914., 220476., 220098., 225804., 225282., 231132.,
      240834., 247116., 246018., 252444., 251202., 257772., 256386., 263100.,
      271938., 279084., 277122., 284412., 282306., 289740., 287490., 295068.,
      365250., 374988., 370434., 380316., 375618., 385644., 380802., 390972.,
      396354., 406956., 401538., 412284., 406722., 417612., 411906., 422940.,
      427458., 438924., 432642., 444252., 437826., 449580., 443010., 454908.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x5x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      32136.,  32400.,  32664.,  32928.,  50236.,  50680.,  51124.,  51568.,
      59356.,  59896.,  60436.,  60976.,  68476.,  69112.,  69748.,  70384.,
      77596.,  78328.,  79060.,  79792.,  50184.,  50704.,  51224.,  51744.,
      72972.,  73656.,  74340.,  75024.,  107322., 108420., 109518., 110616.,
      117546., 118788., 120030., 121272., 127770., 129156., 130542., 131928.,
      137994., 139524., 141054., 142584., 86220.,  87288.,  88356.,  89424.,
      118476., 119736., 120996., 122256., 168666., 170628., 172590., 174552.,
      178890., 180996., 183102., 185208., 189114., 191364., 193614., 195864.,
      199338., 201732., 204126., 206520., 122508., 124152., 125796., 127440.,
      163980., 165816., 167652., 169488., 230010., 232836., 235662., 238488.,
      240234., 243204., 246174., 249144., 250458., 253572., 256686., 259800.,
      260682., 263940., 267198., 270456., 158796., 161016., 163236., 165456.,
      82824.,  84240.,  85656.,  87072.,  110140., 112312., 114484., 116656.,
      114652., 116920., 119188., 121456., 119164., 121528., 123892., 126256.,
      123676., 126136., 128596., 131056., 70152.,  71824.,  73496.,  75168.,
      229896., 232080., 234264., 236448., 323836., 327160., 330484., 333808.,
      332956., 336376., 339796., 343216., 342076., 345592., 349108., 352624.,
      351196., 354808., 358420., 362032., 217224., 219664., 222104., 224544.,
      300492., 304056., 307620., 311184., 414042., 419460., 424878., 430296.,
      424266., 429828., 435390., 440952., 434490., 440196., 445902., 451608.,
      444714., 450564., 456414., 462264., 267660., 271608., 275556., 279504.,
      345996., 350136., 354276., 358416., 475386., 481668., 487950., 494232.,
      485610., 492036., 498462., 504888., 495834., 502404., 508974., 515544.,
      506058., 512772., 519486., 526200., 303948., 308472., 312996., 317520.,
      391500., 396216., 400932., 405648., 536730., 543876., 551022., 558168.,
      546954., 554244., 561534., 568824., 557178., 564612., 572046., 579480.,
      567402., 574980., 582558., 590136., 340236., 345336., 350436., 355536.,
      188424., 191760., 195096., 198432., 245500., 250552., 255604., 260656.,
      250012., 255160., 260308., 265456., 254524., 259768., 265012., 270256.,
      259036., 264376., 269716., 275056., 145032., 148624., 152216., 155808.,
      427656., 431760., 435864., 439968., 597436., 603640., 609844., 616048.,
      606556., 612856., 619156., 625456., 615676., 622072., 628468., 634864.,
      624796., 631288., 637780., 644272., 384264., 388624., 392984., 397344.,
      528012., 534456., 540900., 547344., 720762., 730500., 740238., 749976.,
      730986., 740868., 750750., 760632., 741210., 751236., 761262., 771288.,
      751434., 761604., 771774., 781944., 449100., 455928., 462756., 469584.,
      573516., 580536., 587556., 594576., 782106., 792708., 803310., 813912.,
      792330., 803076., 813822., 824568., 802554., 813444., 824334., 835224.,
      812778., 823812., 834846., 845880., 485388., 492792., 500196., 507600.,
      619020., 626616., 634212., 641808., 843450., 854916., 866382., 877848.,
      853674., 865284., 876894., 888504., 863898., 875652., 887406., 899160.,
      874122., 886020., 897918., 909816., 521676., 529656., 537636., 545616.,
      294024., 299280., 304536., 309792., 380860., 388792., 396724., 404656.,
      385372., 393400., 401428., 409456., 389884., 398008., 406132., 414256.,
      394396., 402616., 410836., 419056., 219912., 225424., 230936., 236448.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x5x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      107322., 108420., 109518., 110616., 117546., 118788., 120030., 121272.,
      127770., 129156., 130542., 131928., 137994., 139524., 141054., 142584.,
      168666., 170628., 172590., 174552., 178890., 180996., 183102., 185208.,
      189114., 191364., 193614., 195864., 199338., 201732., 204126., 206520.,
      230010., 232836., 235662., 238488., 240234., 243204., 246174., 249144.,
      250458., 253572., 256686., 259800., 260682., 263940., 267198., 270456.,
      414042., 419460., 424878., 430296., 424266., 429828., 435390., 440952.,
      434490., 440196., 445902., 451608., 444714., 450564., 456414., 462264.,
      475386., 481668., 487950., 494232., 485610., 492036., 498462., 504888.,
      495834., 502404., 508974., 515544., 506058., 512772., 519486., 526200.,
      536730., 543876., 551022., 558168., 546954., 554244., 561534., 568824.,
      557178., 564612., 572046., 579480., 567402., 574980., 582558., 590136.,
      720762., 730500., 740238., 749976., 730986., 740868., 750750., 760632.,
      741210., 751236., 761262., 771288., 751434., 761604., 771774., 781944.,
      782106., 792708., 803310., 813912., 792330., 803076., 813822., 824568.,
      802554., 813444., 824334., 835224., 812778., 823812., 834846., 845880.,
      843450., 854916., 866382., 877848., 853674., 865284., 876894., 888504.,
      863898., 875652., 887406., 899160., 874122., 886020., 897918., 909816.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x6x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      111.,  178.,  217.,  145.,  231.,  348.,  393.,  252.,  363.,
      528.,  573.,  360.,  495.,  708.,  753.,  468.,  627.,  888.,
      933.,  576.,  325.,  442.,  463.,  271.,  783.,  1114., 1153.,
      721.,  1023., 1428., 1473., 900.,  1155., 1608., 1653., 1008.,
      1287., 1788., 1833., 1116., 1419., 1968., 2013., 1224., 709.,
      946.,  967.,  559.,  1455., 2050., 2089., 1297., 1815., 2508.,
      2553., 1548., 1947., 2688., 2733., 1656., 2079., 2868., 2913.,
      1764., 2211., 3048., 3093., 1872., 1093., 1450., 1471., 847.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x6x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      348.,  393.,  528.,  573.,  708.,  753.,  888.,  933.,
      1428., 1473., 1608., 1653., 1788., 1833., 1968., 2013.,
      2508., 2553., 2688., 2733., 2868., 2913., 3048., 3093.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x6x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      208.,  222.,  332.,  356.,  404.,  434.,  268.,  290.,  429.,  462.,
      642.,  696.,  723.,  786.,  459.,  504.,  669.,  726.,  966.,  1056.,
      1047., 1146., 651.,  720.,  909.,  990.,  1290., 1416., 1371., 1506.,
      843.,  936.,  1149., 1254., 1614., 1776., 1695., 1866., 1035., 1152.,
      572.,  650.,  764.,  884.,  800.,  926.,  456.,  542.,  1456., 1566.,
      2060., 2228., 2132., 2306., 1324., 1442., 1869., 2046., 2586., 2856.,
      2667., 2946., 1611., 1800., 2109., 2310., 2910., 3216., 2991., 3306.,
      1803., 2016., 2349., 2574., 3234., 3576., 3315., 3666., 1995., 2232.,
      2589., 2838., 3558., 3936., 3639., 4026., 2187., 2448., 1244., 1418.,
      1628., 1892., 1664., 1934., 936.,  1118., 2704., 2910., 3788., 4100.,
      3860., 4178., 2380., 2594., 3309., 3630., 4530., 5016., 4611., 5106.,
      2763., 3096., 3549., 3894., 4854., 5376., 4935., 5466., 2955., 3312.,
      3789., 4158., 5178., 5736., 5259., 5826., 3147., 3528., 4029., 4422.,
      5502., 6096., 5583., 6186., 3339., 3744., 1916., 2186., 2492., 2900.,
      2528., 2942., 1416., 1694.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x6x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      642.,  696.,  723.,  786.,  966.,  1056., 1047., 1146., 1290., 1416.,
      1371., 1506., 1614., 1776., 1695., 1866., 2586., 2856., 2667., 2946.,
      2910., 3216., 2991., 3306., 3234., 3576., 3315., 3666., 3558., 3936.,
      3639., 4026., 4530., 5016., 4611., 5106., 4854., 5376., 4935., 5466.,
      5178., 5736., 5259., 5826., 5502., 6096., 5583., 6186.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x6x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      402.,   416.,   430.,   444.,   640.,   664.,   688.,   712.,   778.,
      808.,   838.,   868.,   514.,   536.,   558.,   580.,   825.,   858.,
      891.,   924.,   1230.,  1284.,  1338.,  1392.,  1383.,  1446.,  1509.,
      1572.,  873.,   918.,   963.,   1008.,  1281.,  1338.,  1395.,  1452.,
      1842.,  1932.,  2022.,  2112.,  1995.,  2094.,  2193.,  2292.,  1233.,
      1302.,  1371.,  1440.,  1737.,  1818.,  1899.,  1980.,  2454.,  2580.,
      2706.,  2832.,  2607.,  2742.,  2877.,  3012.,  1593.,  1686.,  1779.,
      1872.,  2193.,  2298.,  2403.,  2508.,  3066.,  3228.,  3390.,  3552.,
      3219.,  3390.,  3561.,  3732.,  1953.,  2070.,  2187.,  2304.,  1066.,
      1144.,  1222.,  1300.,  1408.,  1528.,  1648.,  1768.,  1474.,  1600.,
      1726.,  1852.,  826.,   912.,   998.,   1084.,  2802.,  2912.,  3022.,
      3132.,  3952.,  4120.,  4288.,  4456.,  4090.,  4264.,  4438.,  4612.,
      2530.,  2648.,  2766.,  2884.,  3561.,  3738.,  3915.,  4092.,  4902.,
      5172.,  5442.,  5712.,  5055.,  5334.,  5613.,  5892.,  3033.,  3222.,
      3411.,  3600.,  4017.,  4218.,  4419.,  4620.,  5514.,  5820.,  6126.,
      6432.,  5667.,  5982.,  6297.,  6612.,  3393.,  3606.,  3819.,  4032.,
      4473.,  4698.,  4923.,  5148.,  6126.,  6468.,  6810.,  7152.,  6279.,
      6630.,  6981.,  7332.,  3753.,  3990.,  4227.,  4464.,  4929.,  5178.,
      5427.,  5676.,  6738.,  7116.,  7494.,  7872.,  6891.,  7278.,  7665.,
      8052.,  4113.,  4374.,  4635.,  4896.,  2314.,  2488.,  2662.,  2836.,
      2992.,  3256.,  3520.,  3784.,  3058.,  3328.,  3598.,  3868.,  1690.,
      1872.,  2054.,  2236.,  5202.,  5408.,  5614.,  5820.,  7264.,  7576.,
      7888.,  8200.,  7402.,  7720.,  8038.,  8356.,  4546.,  4760.,  4974.,
      5188.,  6297.,  6618.,  6939.,  7260.,  8574.,  9060.,  9546.,  10032.,
      8727.,  9222.,  9717.,  10212., 5193.,  5526.,  5859.,  6192.,  6753.,
      7098.,  7443.,  7788.,  9186.,  9708.,  10230., 10752., 9339.,  9870.,
      10401., 10932., 5553.,  5910.,  6267.,  6624.,  7209.,  7578.,  7947.,
      8316.,  9798.,  10356., 10914., 11472., 9951.,  10518., 11085., 11652.,
      5913.,  6294.,  6675.,  7056.,  7665.,  8058.,  8451.,  8844.,  10410.,
      11004., 11598., 12192., 10563., 11166., 11769., 12372., 6273.,  6678.,
      7083.,  7488.,  3562.,  3832.,  4102.,  4372.,  4576.,  4984.,  5392.,
      5800.,  4642.,  5056.,  5470.,  5884.,  2554.,  2832.,  3110.,  3388.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x6x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1230.,  1284.,  1338.,  1392.,  1383.,  1446.,  1509.,  1572.,  1842.,
      1932.,  2022.,  2112.,  1995.,  2094.,  2193.,  2292.,  2454.,  2580.,
      2706.,  2832.,  2607.,  2742.,  2877.,  3012.,  3066.,  3228.,  3390.,
      3552.,  3219.,  3390.,  3561.,  3732.,  4902.,  5172.,  5442.,  5712.,
      5055.,  5334.,  5613.,  5892.,  5514.,  5820.,  6126.,  6432.,  5667.,
      5982.,  6297.,  6612.,  6126.,  6468.,  6810.,  7152.,  6279.,  6630.,
      6981.,  7332.,  6738.,  7116.,  7494.,  7872.,  6891.,  7278.,  7665.,
      8052.,  8574.,  9060.,  9546.,  10032., 8727.,  9222.,  9717.,  10212.,
      9186.,  9708.,  10230., 10752., 9339.,  9870.,  10401., 10932., 9798.,
      10356., 10914., 11472., 9951.,  10518., 11085., 11652., 10410., 11004.,
      11598., 12192., 10563., 11166., 11769., 12372.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x6x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      808.,   1304.,  1604.,  1072.,  1722.,  2595.,  2937.,  1878.,  2730.,
      3963.,  4305.,  2694.,  3738.,  5331.,  5673.,  3510.,  4746.,  6699.,
      7041.,  4326.,  2416.,  3260.,  3416.,  1976.,  5992.,  8504.,  8804.,
      5488.,  7770.,  10803., 11145., 6774.,  8778.,  12171., 12513., 7590.,
      9786.,  13539., 13881., 8406.,  10794., 14907., 15249., 9222.,  5296.,
      7004.,  7160.,  4088.,  11176., 15704., 16004., 9904.,  13818., 19011.,
      19353., 11670., 14826., 20379., 20721., 12486., 15834., 21747., 22089.,
      13302., 16842., 23115., 23457., 14118., 8176.,  10748., 10904., 6200.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x6x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2595.,  2937.,  3963.,  4305.,  5331.,  5673.,  6699.,  7041.,
      10803., 11145., 12171., 12513., 13539., 13881., 14907., 15249.,
      19011., 19353., 20379., 20721., 21747., 22089., 23115., 23457.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x6x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1564.,  1616.,  2518.,  2608.,  3094.,  3208.,  2060.,  2144.,  3318.,
      3444.,  4983.,  5190.,  5631.,  5874.,  3582.,  3756.,  5238.,  5460.,
      7575.,  7926.,  8223.,  8610.,  5118.,  5388.,  7158.,  7476.,  10167.,
      10662., 10815., 11346., 6654.,  7020.,  9078.,  9492.,  12759., 13398.,
      13407., 14082., 8190.,  8652.,  4524.,  4832.,  6046.,  6520.,  6334.,
      6832.,  3612.,  3952.,  11548., 11984., 16342., 17008., 16918., 17608.,
      10508., 10976., 14838., 15540., 20535., 21606., 21183., 22290., 12798.,
      13548., 16758., 17556., 23127., 24342., 23775., 25026., 14334., 15180.,
      18678., 19572., 25719., 27078., 26367., 27762., 15870., 16812., 20598.,
      21588., 28311., 29814., 28959., 30498., 17406., 18444., 9900.,  10592.,
      12958., 14008., 13246., 14320., 7452.,  8176.,  21532., 22352., 30166.,
      31408., 30742., 32008., 18956., 19808., 26358., 27636., 36087., 38022.,
      36735., 38706., 22014., 23340., 28278., 29652., 38679., 40758., 39327.,
      41442., 23550., 24972., 30198., 31668., 41271., 43494., 41919., 44178.,
      25086., 26604., 32118., 33684., 43863., 46230., 44511., 46914., 26622.,
      28236., 15276., 16352., 19870., 21496., 20158., 21808., 11292., 12400.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x6x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4983.,  5190.,  5631.,  5874.,  7575.,  7926.,  8223.,  8610.,
      10167., 10662., 10815., 11346., 12759., 13398., 13407., 14082.,
      20535., 21606., 21183., 22290., 23127., 24342., 23775., 25026.,
      25719., 27078., 26367., 27762., 28311., 29814., 28959., 30498.,
      36087., 38022., 36735., 38706., 38679., 40758., 39327., 41442.,
      41271., 43494., 41919., 44178., 43863., 46230., 44511., 46914.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x6x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3076.,  3128.,  3180.,  3232.,  4946.,  5036.,  5126.,  5216.,  6074.,
      6188.,  6302.,  6416.,  4036.,  4120.,  4204.,  4288.,  6510.,  6636.,
      6762.,  6888.,  9759.,  9966.,  10173., 10380., 11019., 11262., 11505.,
      11748., 6990.,  7164.,  7338.,  7512.,  10254., 10476., 10698., 10920.,
      14799., 15150., 15501., 15852., 16059., 16446., 16833., 17220., 9966.,
      10236., 10506., 10776., 13998., 14316., 14634., 14952., 19839., 20334.,
      20829., 21324., 21099., 21630., 22161., 22692., 12942., 13308., 13674.,
      14040., 17742., 18156., 18570., 18984., 24879., 25518., 26157., 26796.,
      26139., 26814., 27489., 28164., 15918., 16380., 16842., 17304., 8740.,
      9048.,  9356.,  9664.,  11618., 12092., 12566., 13040., 12170., 12668.,
      13166., 13664., 6884.,  7224.,  7564.,  7904.,  22660., 23096., 23532.,
      23968., 32018., 32684., 33350., 34016., 33146., 33836., 34526., 35216.,
      20548., 21016., 21484., 21952., 28974., 29676., 30378., 31080., 39999.,
      41070., 42141., 43212., 41259., 42366., 43473., 44580., 24846., 25596.,
      26346., 27096., 32718., 33516., 34314., 35112., 45039., 46254., 47469.,
      48684., 46299., 47550., 48801., 50052., 27822., 28668., 29514., 30360.,
      36462., 37356., 38250., 39144., 50079., 51438., 52797., 54156., 51339.,
      52734., 54129., 55524., 30798., 31740., 32682., 33624., 40206., 41196.,
      42186., 43176., 55119., 56622., 58125., 59628., 56379., 57918., 59457.,
      60996., 33774., 34812., 35850., 36888., 19108., 19800., 20492., 21184.,
      24866., 25916., 26966., 28016., 25418., 26492., 27566., 28640., 14180.,
      14904., 15628., 16352., 42244., 43064., 43884., 44704., 59090., 60332.,
      61574., 62816., 60218., 61484., 62750., 64016., 37060., 37912., 38764.,
      39616., 51438., 52716., 53994., 55272., 70239., 72174., 74109., 76044.,
      71499., 73470., 75441., 77412., 42702., 44028., 45354., 46680., 55182.,
      56556., 57930., 59304., 75279., 77358., 79437., 81516., 76539., 78654.,
      80769., 82884., 45678., 47100., 48522., 49944., 58926., 60396., 61866.,
      63336., 80319., 82542., 84765., 86988., 81579., 83838., 86097., 88356.,
      48654., 50172., 51690., 53208., 62670., 64236., 65802., 67368., 85359.,
      87726., 90093., 92460., 86619., 89022., 91425., 93828., 51630., 53244.,
      54858., 56472., 29476., 30552., 31628., 32704., 38114., 39740., 41366.,
      42992., 38666., 40316., 41966., 43616., 21476., 22584., 23692., 24800.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x6x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      9759.,  9966.,  10173., 10380., 11019., 11262., 11505., 11748., 14799.,
      15150., 15501., 15852., 16059., 16446., 16833., 17220., 19839., 20334.,
      20829., 21324., 21099., 21630., 22161., 22692., 24879., 25518., 26157.,
      26796., 26139., 26814., 27489., 28164., 39999., 41070., 42141., 43212.,
      41259., 42366., 43473., 44580., 45039., 46254., 47469., 48684., 46299.,
      47550., 48801., 50052., 50079., 51438., 52797., 54156., 51339., 52734.,
      54129., 55524., 55119., 56622., 58125., 59628., 56379., 57918., 59457.,
      60996., 70239., 72174., 74109., 76044., 71499., 73470., 75441., 77412.,
      75279., 77358., 79437., 81516., 76539., 78654., 80769., 82884., 80319.,
      82542., 84765., 86988., 81579., 83838., 86097., 88356., 85359., 87726.,
      90093., 92460., 86619., 89022., 91425., 93828.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x6x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6152.,   9964.,   12316.,  8232.,   13284.,  20022.,  22686.,  14484.,
      21156.,  30678.,  33342.,  20820.,  29028.,  41334.,  43998.,  27156.,
      36900.,  51990.,  54654.,  33492.,  18600.,  24988.,  26188.,  15048.,
      46856.,  66412.,  68764.,  42792.,  60516.,  83958.,  86622.,  52500.,
      68388.,  94614.,  97278.,  58836.,  76260.,  105270., 107934., 65172.,
      84132.,  115926., 118590., 71508.,  40872.,  53788.,  54988.,  31176.,
      87560.,  122860., 125212., 77352.,  107748., 147894., 150558., 90516.,
      115620., 158550., 161214., 96852.,  123492., 169206., 171870., 103188.,
      131364., 179862., 182526., 109524., 63144.,  82588.,  83788.,  47304.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x6x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      20022.,  22686.,  30678.,  33342.,  41334.,  43998.,  51990.,  54654.,
      83958.,  86622.,  94614.,  97278.,  105270., 107934., 115926., 118590.,
      147894., 150558., 158550., 161214., 169206., 171870., 179862., 182526.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x6x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      12104.,  12304.,  19580.,  19928.,  24188.,  24632.,  16136.,  16464.,
      26076.,  26568.,  39234.,  40044.,  44418.,  45372.,  28284.,  28968.,
      41436.,  42312.,  59970.,  61356.,  65154.,  66684.,  40572.,  41640.,
      56796.,  58056.,  80706.,  82668.,  85890.,  87996.,  52860.,  54312.,
      72156.,  73800.,  101442., 103980., 106626., 109308., 65148.,  66984.,
      35976.,  37200.,  48092.,  49976.,  50396.,  52376.,  28744.,  30096.,
      91976.,  93712.,  130172., 132824., 134780., 137528., 83720.,  85584.,
      118236., 121032., 163650., 167916., 168834., 173244., 102012., 105000.,
      133596., 136776., 184386., 189228., 189570., 194556., 114300., 117672.,
      148956., 152520., 205122., 210540., 210306., 215868., 126588., 130344.,
      164316., 168264., 225858., 231852., 231042., 237180., 138876., 143016.,
      78984.,  81744.,  103388., 107576., 105692., 109976., 59464.,  62352.,
      171848., 175120., 240764., 245720., 245372., 250424., 151304., 154704.,
      210396., 215496., 288066., 295788., 293250., 301116., 175740., 181032.,
      225756., 231240., 308802., 317100., 313986., 322428., 188028., 193704.,
      241116., 246984., 329538., 338412., 334722., 343740., 200316., 206376.,
      256476., 262728., 350274., 359724., 355458., 365052., 212604., 219048.,
      121992., 126288., 158684., 165176., 160988., 167576., 90184.,  94608.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x6x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      39234.,  40044.,  44418.,  45372.,  59970.,  61356.,  65154.,  66684.,
      80706.,  82668.,  85890.,  87996.,  101442., 103980., 106626., 109308.,
      163650., 167916., 168834., 173244., 184386., 189228., 189570., 194556.,
      205122., 210540., 210306., 215868., 225858., 231852., 231042., 237180.,
      288066., 295788., 293250., 301116., 308802., 317100., 313986., 322428.,
      329538., 338412., 334722., 343740., 350274., 359724., 355458., 365052.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x6x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      24008.,  24208.,  24408.,  24608.,  38812.,  39160.,  39508.,  39856.,
      47932.,  48376.,  48820.,  49264.,  31944.,  32272.,  32600.,  32928.,
      51660.,  52152.,  52644.,  53136.,  77658.,  78468.,  79278.,  80088.,
      87882.,  88836.,  89790.,  90744.,  55884.,  56568.,  57252.,  57936.,
      81996.,  82872.,  83748.,  84624.,  118554., 119940., 121326., 122712.,
      128778., 130308., 131838., 133368., 80076.,  81144.,  82212.,  83280.,
      112332., 113592., 114852., 116112., 159450., 161412., 163374., 165336.,
      169674., 171780., 173886., 175992., 104268., 105720., 107172., 108624.,
      142668., 144312., 145956., 147600., 200346., 202884., 205422., 207960.,
      210570., 213252., 215934., 218616., 128460., 130296., 132132., 133968.,
      70728.,  71952.,  73176.,  74400.,  94300.,  96184.,  98068.,  99952.,
      98812.,  100792., 102772., 104752., 56136.,  57488.,  58840.,  60192.,
      182216., 183952., 185688., 187424., 257692., 260344., 262996., 265648.,
      266812., 269560., 272308., 275056., 165576., 167440., 169304., 171168.,
      233676., 236472., 239268., 242064., 323034., 327300., 331566., 335832.,
      333258., 337668., 342078., 346488., 201036., 204024., 207012., 210000.,
      264012., 267192., 270372., 273552., 363930., 368772., 373614., 378456.,
      374154., 379140., 384126., 389112., 225228., 228600., 231972., 235344.,
      294348., 297912., 301476., 305040., 404826., 410244., 415662., 421080.,
      415050., 420612., 426174., 431736., 249420., 253176., 256932., 260688.,
      324684., 328632., 332580., 336528., 445722., 451716., 457710., 463704.,
      455946., 462084., 468222., 474360., 273612., 277752., 281892., 286032.,
      155208., 157968., 160728., 163488., 202588., 206776., 210964., 215152.,
      207100., 211384., 215668., 219952., 116040., 118928., 121816., 124704.,
      340424., 343696., 346968., 350240., 476572., 481528., 486484., 491440.,
      485692., 490744., 495796., 500848., 299208., 302608., 306008., 309408.,
      415692., 420792., 425892., 430992., 568410., 576132., 583854., 591576.,
      578634., 586500., 594366., 602232., 346188., 351480., 356772., 362064.,
      446028., 451512., 456996., 462480., 609306., 617604., 625902., 634200.,
      619530., 627972., 636414., 644856., 370380., 376056., 381732., 387408.,
      476364., 482232., 488100., 493968., 650202., 659076., 667950., 676824.,
      660426., 669444., 678462., 687480., 394572., 400632., 406692., 412752.,
      506700., 512952., 519204., 525456., 691098., 700548., 709998., 719448.,
      701322., 710916., 720510., 730104., 418764., 425208., 431652., 438096.,
      239688., 243984., 248280., 252576., 310876., 317368., 323860., 330352.,
      315388., 321976., 328564., 335152., 175944., 180368., 184792., 189216.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x6x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      77658.,  78468.,  79278.,  80088.,  87882.,  88836.,  89790.,  90744.,
      118554., 119940., 121326., 122712., 128778., 130308., 131838., 133368.,
      159450., 161412., 163374., 165336., 169674., 171780., 173886., 175992.,
      200346., 202884., 205422., 207960., 210570., 213252., 215934., 218616.,
      323034., 327300., 331566., 335832., 333258., 337668., 342078., 346488.,
      363930., 368772., 373614., 378456., 374154., 379140., 384126., 389112.,
      404826., 410244., 415662., 421080., 415050., 420612., 426174., 431736.,
      445722., 451716., 457710., 463704., 455946., 462084., 468222., 474360.,
      568410., 576132., 583854., 591576., 578634., 586500., 594366., 602232.,
      609306., 617604., 625902., 634200., 619530., 627972., 636414., 644856.,
      650202., 659076., 667950., 676824., 660426., 669444., 678462., 687480.,
      691098., 700548., 709998., 719448., 701322., 710916., 720510., 730104.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x6x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      128.,  202.,  241.,  280.,  184.,  276.,  411.,  456.,  501.,  318.,
      441.,  636.,  681.,  726.,  453.,  606.,  861.,  906.,  951.,  588.,
      771.,  1086., 1131., 1176., 723.,  400.,  541.,  562.,  583.,  340.,
      968.,  1372., 1411., 1450., 904.,  1266., 1761., 1806., 1851., 1128.,
      1431., 1986., 2031., 2076., 1263., 1596., 2211., 2256., 2301., 1398.,
      1761., 2436., 2481., 2526., 1533., 880.,  1171., 1192., 1213., 700.,
      1808., 2542., 2581., 2620., 1624., 2256., 3111., 3156., 3201., 1938.,
      2421., 3336., 3381., 3426., 2073., 2586., 3561., 3606., 3651., 2208.,
      2751., 3786., 3831., 3876., 2343., 1360., 1801., 1822., 1843., 1060.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x6x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      411.,  456.,  501.,  636.,  681.,  726.,  861.,  906.,  951.,
      1086., 1131., 1176., 1761., 1806., 1851., 1986., 2031., 2076.,
      2211., 2256., 2301., 2436., 2481., 2526., 3111., 3156., 3201.,
      3336., 3381., 3426., 3561., 3606., 3651., 3786., 3831., 3876.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x6x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      240.,  256.,  377.,  404.,  449.,  482.,  521.,  560.,  340.,  368.,
      513.,  552.,  759.,  822.,  840.,  912.,  921.,  1002., 579.,  636.,
      813.,  882.,  1164., 1272., 1245., 1362., 1326., 1452., 819.,  906.,
      1113., 1212., 1569., 1722., 1650., 1812., 1731., 1902., 1059., 1176.,
      1413., 1542., 1974., 2172., 2055., 2262., 2136., 2352., 1299., 1446.,
      704.,  800.,  935.,  1082., 971.,  1124., 1007., 1166., 572.,  680.,
      1800., 1936., 2537., 2744., 2609., 2822., 2681., 2900., 1660., 1808.,
      2313., 2532., 3189., 3522., 3270., 3612., 3351., 3702., 2019., 2256.,
      2613., 2862., 3594., 3972., 3675., 4062., 3756., 4152., 2259., 2526.,
      2913., 3192., 3999., 4422., 4080., 4512., 4161., 4602., 2499., 2796.,
      3213., 3522., 4404., 4872., 4485., 4962., 4566., 5052., 2739., 3066.,
      1544., 1760., 2015., 2342., 2051., 2384., 2087., 2426., 1172., 1400.,
      3360., 3616., 4697., 5084., 4769., 5162., 4841., 5240., 2980., 3248.,
      4113., 4512., 5619., 6222., 5700., 6312., 5781., 6402., 3459., 3876.,
      4413., 4842., 6024., 6672., 6105., 6762., 6186., 6852., 3699., 4146.,
      4713., 5172., 6429., 7122., 6510., 7212., 6591., 7302., 3939., 4416.,
      5013., 5502., 6834., 7572., 6915., 7662., 6996., 7752., 4179., 4686.,
      2384., 2720., 3095., 3602., 3131., 3644., 3167., 3686., 1772., 2120.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x6x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      759.,  822.,  840.,  912.,  921.,  1002., 1164., 1272., 1245.,
      1362., 1326., 1452., 1569., 1722., 1650., 1812., 1731., 1902.,
      1974., 2172., 2055., 2262., 2136., 2352., 3189., 3522., 3270.,
      3612., 3351., 3702., 3594., 3972., 3675., 4062., 3756., 4152.,
      3999., 4422., 4080., 4512., 4161., 4602., 4404., 4872., 4485.,
      4962., 4566., 5052., 5619., 6222., 5700., 6312., 5781., 6402.,
      6024., 6672., 6105., 6762., 6186., 6852., 6429., 7122., 6510.,
      7212., 6591., 7302., 6834., 7572., 6915., 7662., 6996., 7752.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x6x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      464.,   480.,   496.,   512.,   727.,   754.,   781.,   808.,   865.,
      898.,   931.,   964.,   1003.,  1042.,  1081.,  1120.,  652.,   680.,
      708.,   736.,   987.,   1026.,  1065.,  1104.,  1455.,  1518.,  1581.,
      1644.,  1608.,  1680.,  1752.,  1824.,  1761.,  1842.,  1923.,  2004.,
      1101.,  1158.,  1215.,  1272.,  1557.,  1626.,  1695.,  1764.,  2220.,
      2328.,  2436.,  2544.,  2373.,  2490.,  2607.,  2724.,  2526.,  2652.,
      2778.,  2904.,  1551.,  1638.,  1725.,  1812.,  2127.,  2226.,  2325.,
      2424.,  2985.,  3138.,  3291.,  3444.,  3138.,  3300.,  3462.,  3624.,
      3291.,  3462.,  3633.,  3804.,  2001.,  2118.,  2235.,  2352.,  2697.,
      2826.,  2955.,  3084.,  3750.,  3948.,  4146.,  4344.,  3903.,  4110.,
      4317.,  4524.,  4056.,  4272.,  4488.,  4704.,  2451.,  2598.,  2745.,
      2892.,  1312.,  1408.,  1504.,  1600.,  1723.,  1870.,  2017.,  2164.,
      1789.,  1942.,  2095.,  2248.,  1855.,  2014.,  2173.,  2332.,  1036.,
      1144.,  1252.,  1360.,  3464.,  3600.,  3736.,  3872.,  4867.,  5074.,
      5281.,  5488.,  5005.,  5218.,  5431.,  5644.,  5143.,  5362.,  5581.,
      5800.,  3172.,  3320.,  3468.,  3616.,  4407.,  4626.,  4845.,  5064.,
      6045.,  6378.,  6711.,  7044.,  6198.,  6540.,  6882.,  7224.,  6351.,
      6702.,  7053.,  7404.,  3801.,  4038.,  4275.,  4512.,  4977.,  5226.,
      5475.,  5724.,  6810.,  7188.,  7566.,  7944.,  6963.,  7350.,  7737.,
      8124.,  7116.,  7512.,  7908.,  8304.,  4251.,  4518.,  4785.,  5052.,
      5547.,  5826.,  6105.,  6384.,  7575.,  7998.,  8421.,  8844.,  7728.,
      8160.,  8592.,  9024.,  7881.,  8322.,  8763.,  9204.,  4701.,  4998.,
      5295.,  5592.,  6117.,  6426.,  6735.,  7044.,  8340.,  8808.,  9276.,
      9744.,  8493.,  8970.,  9447.,  9924.,  8646.,  9132.,  9618.,  10104.,
      5151.,  5478.,  5805.,  6132.,  2872.,  3088.,  3304.,  3520.,  3703.,
      4030.,  4357.,  4684.,  3769.,  4102.,  4435.,  4768.,  3835.,  4174.,
      4513.,  4852.,  2116.,  2344.,  2572.,  2800.,  6464.,  6720.,  6976.,
      7232.,  9007.,  9394.,  9781.,  10168., 9145.,  9538.,  9931.,  10324.,
      9283.,  9682.,  10081., 10480., 5692.,  5960.,  6228.,  6496.,  7827.,
      8226.,  8625.,  9024.,  10635., 11238., 11841., 12444., 10788., 11400.,
      12012., 12624., 10941., 11562., 12183., 12804., 6501.,  6918.,  7335.,
      7752.,  8397.,  8826.,  9255.,  9684.,  11400., 12048., 12696., 13344.,
      11553., 12210., 12867., 13524., 11706., 12372., 13038., 13704., 6951.,
      7398.,  7845.,  8292.,  8967.,  9426.,  9885.,  10344., 12165., 12858.,
      13551., 14244., 12318., 13020., 13722., 14424., 12471., 13182., 13893.,
      14604., 7401.,  7878.,  8355.,  8832.,  9537.,  10026., 10515., 11004.,
      12930., 13668., 14406., 15144., 13083., 13830., 14577., 15324., 13236.,
      13992., 14748., 15504., 7851.,  8358.,  8865.,  9372.,  4432.,  4768.,
      5104.,  5440.,  5683.,  6190.,  6697.,  7204.,  5749.,  6262.,  6775.,
      7288.,  5815.,  6334.,  6853.,  7372.,  3196.,  3544.,  3892.,  4240.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x6x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1455.,  1518.,  1581.,  1644.,  1608.,  1680.,  1752.,  1824.,  1761.,
      1842.,  1923.,  2004.,  2220.,  2328.,  2436.,  2544.,  2373.,  2490.,
      2607.,  2724.,  2526.,  2652.,  2778.,  2904.,  2985.,  3138.,  3291.,
      3444.,  3138.,  3300.,  3462.,  3624.,  3291.,  3462.,  3633.,  3804.,
      3750.,  3948.,  4146.,  4344.,  3903.,  4110.,  4317.,  4524.,  4056.,
      4272.,  4488.,  4704.,  6045.,  6378.,  6711.,  7044.,  6198.,  6540.,
      6882.,  7224.,  6351.,  6702.,  7053.,  7404.,  6810.,  7188.,  7566.,
      7944.,  6963.,  7350.,  7737.,  8124.,  7116.,  7512.,  7908.,  8304.,
      7575.,  7998.,  8421.,  8844.,  7728.,  8160.,  8592.,  9024.,  7881.,
      8322.,  8763.,  9204.,  8340.,  8808.,  9276.,  9744.,  8493.,  8970.,
      9447.,  9924.,  8646.,  9132.,  9618.,  10104., 10635., 11238., 11841.,
      12444., 10788., 11400., 12012., 12624., 10941., 11562., 12183., 12804.,
      11400., 12048., 12696., 13344., 11553., 12210., 12867., 13524., 11706.,
      12372., 13038., 13704., 12165., 12858., 13551., 14244., 12318., 13020.,
      13722., 14424., 12471., 13182., 13893., 14604., 12930., 13668., 14406.,
      15144., 13083., 13830., 14577., 15324., 13236., 13992., 14748., 15504.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x6x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      940.,   1490.,  1790.,  2090.,  1372.,  2070.,  3081.,  3423.,  3765.,
      2382.,  3330.,  4791.,  5133.,  5475.,  3402.,  4590.,  6501.,  6843.,
      7185.,  4422.,  5850.,  8211.,  8553.,  8895.,  5442.,  2980.,  3998.,
      4154.,  4310.,  2484.,  7420.,  10490., 10790., 11090., 6892.,  9630.,
      13341., 13683., 14025., 8502.,  10890., 15051., 15393., 15735., 9522.,
      12150., 16761., 17103., 17445., 10542., 13410., 18471., 18813., 19155.,
      11562., 6580.,  8678.,  8834.,  8990.,  5124.,  13900., 19490., 19790.,
      20090., 12412., 17190., 23601., 23943., 24285., 14622., 18450., 25311.,
      25653., 25995., 15642., 19710., 27021., 27363., 27705., 16662., 20970.,
      28731., 29073., 29415., 17682., 10180., 13358., 13514., 13670., 7764.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x6x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3081.,  3423.,  3765.,  4791.,  5133.,  5475.,  6501.,  6843.,  7185.,
      8211.,  8553.,  8895.,  13341., 13683., 14025., 15051., 15393., 15735.,
      16761., 17103., 17445., 18471., 18813., 19155., 23601., 23943., 24285.,
      25311., 25653., 25995., 27021., 27363., 27705., 28731., 29073., 29415.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x6x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1820.,  1880.,  2878.,  2980.,  3454.,  3580.,  4030.,  4180.,  2636.,
      2744.,  3990.,  4140.,  5919.,  6162.,  6567.,  6846.,  7215.,  7530.,
      4542.,  4764.,  6390.,  6660.,  9159.,  9582.,  9807.,  10266., 10455.,
      10950., 6462.,  6804.,  8790.,  9180.,  12399., 13002., 13047., 13686.,
      13695., 14370., 8382.,  8844.,  11190., 11700., 15639., 16422., 16287.,
      17106., 16935., 17790., 10302., 10884., 5580.,  5960.,  7414.,  7996.,
      7702.,  8308.,  7990.,  8620.,  4540.,  4968.,  14300., 14840., 20158.,
      20980., 20734., 21580., 21310., 22180., 13196., 13784., 18390., 19260.,
      25359., 26682., 26007., 27366., 26655., 28050., 16062., 17004., 20790.,
      21780., 28599., 30102., 29247., 30786., 29895., 31470., 17982., 19044.,
      23190., 24300., 31839., 33522., 32487., 34206., 33135., 34890., 19902.,
      21084., 25590., 26820., 35079., 36942., 35727., 37626., 36375., 38310.,
      21822., 23124., 12300., 13160., 16054., 17356., 16342., 17668., 16630.,
      17980., 9340.,  10248., 26780., 27800., 37438., 38980., 38014., 39580.,
      38590., 40180., 23756., 24824., 32790., 34380., 44799., 47202., 45447.,
      47886., 46095., 48570., 27582., 29244., 35190., 36900., 48039., 50622.,
      48687., 51306., 49335., 51990., 29502., 31284., 37590., 39420., 51279.,
      54042., 51927., 54726., 52575., 55410., 31422., 33324., 39990., 41940.,
      54519., 57462., 55167., 58146., 55815., 58830., 33342., 35364., 19020.,
      20360., 24694., 26716., 24982., 27028., 25270., 27340., 14140., 15528.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x6x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5919.,  6162.,  6567.,  6846.,  7215.,  7530.,  9159.,  9582.,  9807.,
      10266., 10455., 10950., 12399., 13002., 13047., 13686., 13695., 14370.,
      15639., 16422., 16287., 17106., 16935., 17790., 25359., 26682., 26007.,
      27366., 26655., 28050., 28599., 30102., 29247., 30786., 29895., 31470.,
      31839., 33522., 32487., 34206., 33135., 34890., 35079., 36942., 35727.,
      37626., 36375., 38310., 44799., 47202., 45447., 47886., 46095., 48570.,
      48039., 50622., 48687., 51306., 49335., 51990., 51279., 54042., 51927.,
      54726., 52575., 55410., 54519., 57462., 55167., 58146., 55815., 58830.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x6x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3580.,   3640.,   3700.,   3760.,   5654.,   5756.,   5858.,   5960.,
      6782.,   6908.,   7034.,   7160.,   7910.,   8060.,   8210.,   8360.,
      5164.,   5272.,   5380.,   5488.,   7830.,   7980.,   8130.,   8280.,
      11595.,  11838.,  12081.,  12324.,  12855.,  13134.,  13413.,  13692.,
      14115.,  14430.,  14745.,  15060.,  8862.,   9084.,   9306.,   9528.,
      12510.,  12780.,  13050.,  13320.,  17895.,  18318.,  18741.,  19164.,
      19155.,  19614.,  20073.,  20532.,  20415.,  20910.,  21405.,  21900.,
      12582.,  12924.,  13266.,  13608.,  17190.,  17580.,  17970.,  18360.,
      24195.,  24798.,  25401.,  26004.,  25455.,  26094.,  26733.,  27372.,
      26715.,  27390.,  28065.,  28740.,  16302.,  16764.,  17226.,  17688.,
      21870.,  22380.,  22890.,  23400.,  30495.,  31278.,  32061.,  32844.,
      31755.,  32574.,  33393.,  34212.,  33015.,  33870.,  34725.,  35580.,
      20022.,  20604.,  21186.,  21768.,  10780.,  11160.,  11540.,  11920.,
      14246.,  14828.,  15410.,  15992.,  14798.,  15404.,  16010.,  16616.,
      15350.,  15980.,  16610.,  17240.,  8652.,   9080.,   9508.,   9936.,
      28060.,  28600.,  29140.,  29680.,  39494.,  40316.,  41138.,  41960.,
      40622.,  41468.,  42314.,  43160.,  41750.,  42620.,  43490.,  44360.,
      25804.,  26392.,  26980.,  27568.,  35910.,  36780.,  37650.,  38520.,
      49395.,  50718.,  52041.,  53364.,  50655.,  52014.,  53373.,  54732.,
      51915.,  53310.,  54705.,  56100.,  31182.,  32124.,  33066.,  34008.,
      40590.,  41580.,  42570.,  43560.,  55695.,  57198.,  58701.,  60204.,
      56955.,  58494.,  60033.,  61572.,  58215.,  59790.,  61365.,  62940.,
      34902.,  35964.,  37026.,  38088.,  45270.,  46380.,  47490.,  48600.,
      61995.,  63678.,  65361.,  67044.,  63255.,  64974.,  66693.,  68412.,
      64515.,  66270.,  68025.,  69780.,  38622.,  39804.,  40986.,  42168.,
      49950.,  51180.,  52410.,  53640.,  68295.,  70158.,  72021.,  73884.,
      69555.,  71454.,  73353.,  75252.,  70815.,  72750.,  74685.,  76620.,
      42342.,  43644.,  44946.,  46248.,  23740.,  24600.,  25460.,  26320.,
      30806.,  32108.,  33410.,  34712.,  31358.,  32684.,  34010.,  35336.,
      31910.,  33260.,  34610.,  35960.,  17772.,  18680.,  19588.,  20496.,
      52540.,  53560.,  54580.,  55600.,  73334.,  74876.,  76418.,  77960.,
      74462.,  76028.,  77594.,  79160.,  75590.,  77180.,  78770.,  80360.,
      46444.,  47512.,  48580.,  49648.,  63990.,  65580.,  67170.,  68760.,
      87195.,  89598.,  92001.,  94404.,  88455.,  90894.,  93333.,  95772.,
      89715.,  92190.,  94665.,  97140.,  53502.,  55164.,  56826.,  58488.,
      68670.,  70380.,  72090.,  73800.,  93495.,  96078.,  98661.,  101244.,
      94755.,  97374.,  99993.,  102612., 96015.,  98670.,  101325., 103980.,
      57222.,  59004.,  60786.,  62568.,  73350.,  75180.,  77010.,  78840.,
      99795.,  102558., 105321., 108084., 101055., 103854., 106653., 109452.,
      102315., 105150., 107985., 110820., 60942.,  62844.,  64746.,  66648.,
      78030.,  79980.,  81930.,  83880.,  106095., 109038., 111981., 114924.,
      107355., 110334., 113313., 116292., 108615., 111630., 114645., 117660.,
      64662.,  66684.,  68706.,  70728.,  36700.,  38040.,  39380.,  40720.,
      47366.,  49388.,  51410.,  53432.,  47918.,  49964.,  52010.,  54056.,
      48470.,  50540.,  52610.,  54680.,  26892.,  28280.,  29668.,  31056.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x6x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11595.,  11838.,  12081.,  12324.,  12855.,  13134.,  13413.,  13692.,
      14115.,  14430.,  14745.,  15060.,  17895.,  18318.,  18741.,  19164.,
      19155.,  19614.,  20073.,  20532.,  20415.,  20910.,  21405.,  21900.,
      24195.,  24798.,  25401.,  26004.,  25455.,  26094.,  26733.,  27372.,
      26715.,  27390.,  28065.,  28740.,  30495.,  31278.,  32061.,  32844.,
      31755.,  32574.,  33393.,  34212.,  33015.,  33870.,  34725.,  35580.,
      49395.,  50718.,  52041.,  53364.,  50655.,  52014.,  53373.,  54732.,
      51915.,  53310.,  54705.,  56100.,  55695.,  57198.,  58701.,  60204.,
      56955.,  58494.,  60033.,  61572.,  58215.,  59790.,  61365.,  62940.,
      61995.,  63678.,  65361.,  67044.,  63255.,  64974.,  66693.,  68412.,
      64515.,  66270.,  68025.,  69780.,  68295.,  70158.,  72021.,  73884.,
      69555.,  71454.,  73353.,  75252.,  70815.,  72750.,  74685.,  76620.,
      87195.,  89598.,  92001.,  94404.,  88455.,  90894.,  93333.,  95772.,
      89715.,  92190.,  94665.,  97140.,  93495.,  96078.,  98661.,  101244.,
      94755.,  97374.,  99993.,  102612., 96015.,  98670.,  101325., 103980.,
      99795.,  102558., 105321., 108084., 101055., 103854., 106653., 109452.,
      102315., 105150., 107985., 110820., 106095., 109038., 111981., 114924.,
      107355., 110334., 113313., 116292., 108615., 111630., 114645., 117660.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x6x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7192.,   11428.,  13780.,  16132.,  10584.,  16020.,  23838.,  26502.,
      29166.,  18420.,  25860.,  37158.,  39822.,  42486.,  26340.,  35700.,
      50478.,  53142.,  55806.,  34260.,  45540.,  63798.,  66462.,  69126.,
      42180.,  22968.,  30676.,  31876.,  33076.,  18936.,  58072.,  81988.,
      84340.,  86692.,  53784.,  75060.,  103758., 106422., 109086., 65940.,
      84900.,  117078., 119742., 122406., 73860.,  94740.,  130398., 133062.,
      135726., 81780.,  104580., 143718., 146382., 149046., 89700.,  50808.,
      66676.,  67876.,  69076.,  39096.,  108952., 152548., 154900., 157252.,
      96984.,  134100., 183678., 186342., 189006., 113460., 143940., 196998.,
      199662., 202326., 121380., 153780., 210318., 212982., 215646., 129300.,
      163620., 223638., 226302., 228966., 137220., 78648.,  102676., 103876.,
      105076., 59256.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x6x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      23838.,  26502.,  29166.,  37158.,  39822.,  42486.,  50478.,  53142.,
      55806.,  63798.,  66462.,  69126.,  103758., 106422., 109086., 117078.,
      119742., 122406., 130398., 133062., 135726., 143718., 146382., 149046.,
      183678., 186342., 189006., 196998., 199662., 202326., 210318., 212982.,
      215646., 223638., 226302., 228966.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x6x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      14152.,  14384.,  22460.,  22856.,  27068.,  27560.,  31676.,  32264.,
      20744.,  21168.,  31452.,  32040.,  46722.,  47676.,  51906.,  53004.,
      57090.,  58332.,  35964.,  36840.,  50652.,  51720.,  72642.,  74316.,
      77826.,  79644.,  83010.,  84972.,  51324.,  52680.,  69852.,  71400.,
      98562.,  100956., 103746., 106284., 108930., 111612., 66684.,  68520.,
      89052.,  91080.,  124482., 127596., 129666., 132924., 134850., 138252.,
      82044.,  84360.,  44424.,  45936.,  59036.,  61352.,  61340.,  63752.,
      63644.,  66152.,  36168.,  37872.,  113992., 116144., 160700., 163976.,
      165308., 168680., 169916., 173384., 105224., 107568., 146652., 150120.,
      202242., 207516., 207426., 212844., 212610., 218172., 128124., 131880.,
      165852., 169800., 228162., 234156., 233346., 239484., 238530., 244812.,
      143484., 147720., 185052., 189480., 254082., 260796., 259266., 266124.,
      264450., 271452., 158844., 163560., 204252., 209160., 280002., 287436.,
      285186., 292764., 290370., 298092., 174204., 179400., 98184.,  101616.,
      128156., 133352., 130460., 135752., 132764., 138152., 74568.,  78192.,
      213832., 217904., 298940., 305096., 303548., 309800., 308156., 314504.,
      189704., 193968., 261852., 268200., 357762., 367356., 362946., 372684.,
      368130., 378012., 220284., 226920., 281052., 287880., 383682., 393996.,
      388866., 399324., 394050., 404652., 235644., 242760., 300252., 307560.,
      409602., 420636., 414786., 425964., 419970., 431292., 251004., 258600.,
      319452., 327240., 435522., 447276., 440706., 452604., 445890., 457932.,
      266364., 274440., 151944., 157296., 197276., 205352., 199580., 207752.,
      201884., 210152., 112968., 118512.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x6x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      46722.,  47676.,  51906.,  53004.,  57090.,  58332.,  72642.,  74316.,
      77826.,  79644.,  83010.,  84972.,  98562.,  100956., 103746., 106284.,
      108930., 111612., 124482., 127596., 129666., 132924., 134850., 138252.,
      202242., 207516., 207426., 212844., 212610., 218172., 228162., 234156.,
      233346., 239484., 238530., 244812., 254082., 260796., 259266., 266124.,
      264450., 271452., 280002., 287436., 285186., 292764., 290370., 298092.,
      357762., 367356., 362946., 372684., 368130., 378012., 383682., 393996.,
      388866., 399324., 394050., 404652., 409602., 420636., 414786., 425964.,
      419970., 431292., 435522., 447276., 440706., 452604., 445890., 457932.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x6x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      28072.,  28304.,  28536.,  28768.,  44524.,  44920.,  45316.,  45712.,
      53644.,  54136.,  54628.,  55120.,  62764.,  63352.,  63940.,  64528.,
      41064.,  41488.,  41912.,  42336.,  62316.,  62904.,  63492.,  64080.,
      92490.,  93444.,  94398.,  95352.,  102714., 103812., 104910., 106008.,
      112938., 114180., 115422., 116664., 71052.,  71928.,  72804.,  73680.,
      100236., 101304., 102372., 103440., 143610., 145284., 146958., 148632.,
      153834., 155652., 157470., 159288., 164058., 166020., 167982., 169944.,
      101292., 102648., 104004., 105360., 138156., 139704., 141252., 142800.,
      194730., 197124., 199518., 201912., 204954., 207492., 210030., 212568.,
      215178., 217860., 220542., 223224., 131532., 133368., 135204., 137040.,
      176076., 178104., 180132., 182160., 245850., 248964., 252078., 255192.,
      256074., 259332., 262590., 265848., 266298., 269700., 273102., 276504.,
      161772., 164088., 166404., 168720., 87336.,  88848.,  90360.,  91872.,
      115756., 118072., 120388., 122704., 120268., 122680., 125092., 127504.,
      124780., 127288., 129796., 132304., 70632.,  72336.,  74040.,  75744.,
      225832., 227984., 230136., 232288., 318124., 321400., 324676., 327952.,
      327244., 330616., 333988., 337360., 336364., 339832., 343300., 346768.,
      208104., 210448., 212792., 215136., 289836., 293304., 296772., 300240.,
      399210., 404484., 409758., 415032., 409434., 414852., 420270., 425688.,
      419658., 425220., 430782., 436344., 252492., 256248., 260004., 263760.,
      327756., 331704., 335652., 339600., 450330., 456324., 462318., 468312.,
      460554., 466692., 472830., 478968., 470778., 477060., 483342., 489624.,
      282732., 286968., 291204., 295440., 365676., 370104., 374532., 378960.,
      501450., 508164., 514878., 521592., 511674., 518532., 525390., 532248.,
      521898., 528900., 535902., 542904., 312972., 317688., 322404., 327120.,
      403596., 408504., 413412., 418320., 552570., 560004., 567438., 574872.,
      562794., 570372., 577950., 585528., 573018., 580740., 588462., 596184.,
      343212., 348408., 353604., 358800., 192936., 196368., 199800., 203232.,
      251116., 256312., 261508., 266704., 255628., 260920., 266212., 271504.,
      260140., 265528., 270916., 276304., 145512., 149136., 152760., 156384.,
      423592., 427664., 431736., 435808., 591724., 597880., 604036., 610192.,
      600844., 607096., 613348., 619600., 609964., 616312., 622660., 629008.,
      375144., 379408., 383672., 387936., 517356., 523704., 530052., 536400.,
      705930., 715524., 725118., 734712., 716154., 725892., 735630., 745368.,
      726378., 736260., 746142., 756024., 433932., 440568., 447204., 453840.,
      555276., 562104., 568932., 575760., 757050., 767364., 777678., 787992.,
      767274., 777732., 788190., 798648., 777498., 788100., 798702., 809304.,
      464172., 471288., 478404., 485520., 593196., 600504., 607812., 615120.,
      808170., 819204., 830238., 841272., 818394., 829572., 840750., 851928.,
      828618., 839940., 851262., 862584., 494412., 502008., 509604., 517200.,
      631116., 638904., 646692., 654480., 859290., 871044., 882798., 894552.,
      869514., 881412., 893310., 905208., 879738., 891780., 903822., 915864.,
      524652., 532728., 540804., 548880., 298536., 303888., 309240., 314592.,
      386476., 394552., 402628., 410704., 390988., 399160., 407332., 415504.,
      395500., 403768., 412036., 420304., 220392., 225936., 231480., 237024.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x6x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      92490.,  93444.,  94398.,  95352.,  102714., 103812., 104910., 106008.,
      112938., 114180., 115422., 116664., 143610., 145284., 146958., 148632.,
      153834., 155652., 157470., 159288., 164058., 166020., 167982., 169944.,
      194730., 197124., 199518., 201912., 204954., 207492., 210030., 212568.,
      215178., 217860., 220542., 223224., 245850., 248964., 252078., 255192.,
      256074., 259332., 262590., 265848., 266298., 269700., 273102., 276504.,
      399210., 404484., 409758., 415032., 409434., 414852., 420270., 425688.,
      419658., 425220., 430782., 436344., 450330., 456324., 462318., 468312.,
      460554., 466692., 472830., 478968., 470778., 477060., 483342., 489624.,
      501450., 508164., 514878., 521592., 511674., 518532., 525390., 532248.,
      521898., 528900., 535902., 542904., 552570., 560004., 567438., 574872.,
      562794., 570372., 577950., 585528., 573018., 580740., 588462., 596184.,
      705930., 715524., 725118., 734712., 716154., 725892., 735630., 745368.,
      726378., 736260., 746142., 756024., 757050., 767364., 777678., 787992.,
      767274., 777732., 788190., 798648., 777498., 788100., 798702., 809304.,
      808170., 819204., 830238., 841272., 818394., 829572., 840750., 851928.,
      828618., 839940., 851262., 862584., 859290., 871044., 882798., 894552.,
      869514., 881412., 893310., 905208., 879738., 891780., 903822., 915864.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x6x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      145.,  226.,  265.,  304.,  343.,  223.,  321.,  474.,  519.,  564.,
      609.,  384.,  519.,  744.,  789.,  834.,  879.,  546.,  717.,  1014.,
      1059., 1104., 1149., 708.,  915.,  1284., 1329., 1374., 1419., 870.,
      475.,  640.,  661.,  682.,  703.,  409.,  1153., 1630., 1669., 1708.,
      1747., 1087., 1509., 2094., 2139., 2184., 2229., 1356., 1707., 2364.,
      2409., 2454., 2499., 1518., 1905., 2634., 2679., 2724., 2769., 1680.,
      2103., 2904., 2949., 2994., 3039., 1842., 1051., 1396., 1417., 1438.,
      1459., 841.,  2161., 3034., 3073., 3112., 3151., 1951., 2697., 3714.,
      3759., 3804., 3849., 2328., 2895., 3984., 4029., 4074., 4119., 2490.,
      3093., 4254., 4299., 4344., 4389., 2652., 3291., 4524., 4569., 4614.,
      4659., 2814., 1627., 2152., 2173., 2194., 2215., 1273.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x6x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      474.,  519.,  564.,  609.,  744.,  789.,  834.,  879.,  1014., 1059.,
      1104., 1149., 1284., 1329., 1374., 1419., 2094., 2139., 2184., 2229.,
      2364., 2409., 2454., 2499., 2634., 2679., 2724., 2769., 2904., 2949.,
      2994., 3039., 3714., 3759., 3804., 3849., 3984., 4029., 4074., 4119.,
      4254., 4299., 4344., 4389., 4524., 4569., 4614., 4659.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x6x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      272.,  290.,  422.,  452.,  494.,  530.,  566.,  608.,  638.,  686.,
      412.,  446.,  597.,  642.,  876.,  948.,  957.,  1038., 1038., 1128.,
      1119., 1218., 699.,  768.,  957.,  1038., 1362., 1488., 1443., 1578.,
      1524., 1668., 1605., 1758., 987.,  1092., 1317., 1434., 1848., 2028.,
      1929., 2118., 2010., 2208., 2091., 2298., 1275., 1416., 1677., 1830.,
      2334., 2568., 2415., 2658., 2496., 2748., 2577., 2838., 1563., 1740.,
      836.,  950.,  1106., 1280., 1142., 1322., 1178., 1364., 1214., 1406.,
      688.,  818.,  2144., 2306., 3014., 3260., 3086., 3338., 3158., 3416.,
      3230., 3494., 1996., 2174., 2757., 3018., 3792., 4188., 3873., 4278.,
      3954., 4368., 4035., 4458., 2427., 2712., 3117., 3414., 4278., 4728.,
      4359., 4818., 4440., 4908., 4521., 4998., 2715., 3036., 3477., 3810.,
      4764., 5268., 4845., 5358., 4926., 5448., 5007., 5538., 3003., 3360.,
      3837., 4206., 5250., 5808., 5331., 5898., 5412., 5988., 5493., 6078.,
      3291., 3684., 1844., 2102., 2402., 2792., 2438., 2834., 2474., 2876.,
      2510., 2918., 1408., 1682., 4016., 4322., 5606., 6068., 5678., 6146.,
      5750., 6224., 5822., 6302., 3580., 3902., 4917., 5394., 6708., 7428.,
      6789., 7518., 6870., 7608., 6951., 7698., 4155., 4656., 5277., 5790.,
      7194., 7968., 7275., 8058., 7356., 8148., 7437., 8238., 4443., 4980.,
      5637., 6186., 7680., 8508., 7761., 8598., 7842., 8688., 7923., 8778.,
      4731., 5304., 5997., 6582., 8166., 9048., 8247., 9138., 8328., 9228.,
      8409., 9318., 5019., 5628., 2852., 3254., 3698., 4304., 3734., 4346.,
      3770., 4388., 3806., 4430., 2128., 2546.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x6x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      876.,  948.,  957.,  1038., 1038., 1128., 1119., 1218., 1362., 1488.,
      1443., 1578., 1524., 1668., 1605., 1758., 1848., 2028., 1929., 2118.,
      2010., 2208., 2091., 2298., 2334., 2568., 2415., 2658., 2496., 2748.,
      2577., 2838., 3792., 4188., 3873., 4278., 3954., 4368., 4035., 4458.,
      4278., 4728., 4359., 4818., 4440., 4908., 4521., 4998., 4764., 5268.,
      4845., 5358., 4926., 5448., 5007., 5538., 5250., 5808., 5331., 5898.,
      5412., 5988., 5493., 6078., 6708., 7428., 6789., 7518., 6870., 7608.,
      6951., 7698., 7194., 7968., 7275., 8058., 7356., 8148., 7437., 8238.,
      7680., 8508., 7761., 8598., 7842., 8688., 7923., 8778., 8166., 9048.,
      8247., 9138., 8328., 9228., 8409., 9318.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x6x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      526.,   544.,   562.,   580.,   814.,   844.,   874.,   904.,   952.,
      988.,   1024.,  1060.,  1090.,  1132.,  1174.,  1216.,  1228.,  1276.,
      1324.,  1372.,  790.,   824.,   858.,   892.,   1149.,  1194.,  1239.,
      1284.,  1680.,  1752.,  1824.,  1896.,  1833.,  1914.,  1995.,  2076.,
      1986.,  2076.,  2166.,  2256.,  2139.,  2238.,  2337.,  2436.,  1329.,
      1398.,  1467.,  1536.,  1833.,  1914.,  1995.,  2076.,  2598.,  2724.,
      2850.,  2976.,  2751.,  2886.,  3021.,  3156.,  2904.,  3048.,  3192.,
      3336.,  3057.,  3210.,  3363.,  3516.,  1869.,  1974.,  2079.,  2184.,
      2517.,  2634.,  2751.,  2868.,  3516.,  3696.,  3876.,  4056.,  3669.,
      3858.,  4047.,  4236.,  3822.,  4020.,  4218.,  4416.,  3975.,  4182.,
      4389.,  4596.,  2409.,  2550.,  2691.,  2832.,  3201.,  3354.,  3507.,
      3660.,  4434.,  4668.,  4902.,  5136.,  4587.,  4830.,  5073.,  5316.,
      4740.,  4992.,  5244.,  5496.,  4893.,  5154.,  5415.,  5676.,  2949.,
      3126.,  3303.,  3480.,  1558.,  1672.,  1786.,  1900.,  2038.,  2212.,
      2386.,  2560.,  2104.,  2284.,  2464.,  2644.,  2170.,  2356.,  2542.,
      2728.,  2236.,  2428.,  2620.,  2812.,  1246.,  1376.,  1506.,  1636.,
      4126.,  4288.,  4450.,  4612.,  5782.,  6028.,  6274.,  6520.,  5920.,
      6172.,  6424.,  6676.,  6058.,  6316.,  6574.,  6832.,  6196.,  6460.,
      6724.,  6988.,  3814.,  3992.,  4170.,  4348.,  5253.,  5514.,  5775.,
      6036.,  7188.,  7584.,  7980.,  8376.,  7341.,  7746.,  8151.,  8556.,
      7494.,  7908.,  8322.,  8736.,  7647.,  8070.,  8493.,  8916.,  4569.,
      4854.,  5139.,  5424.,  5937.,  6234.,  6531.,  6828.,  8106.,  8556.,
      9006.,  9456.,  8259.,  8718.,  9177.,  9636.,  8412.,  8880.,  9348.,
      9816.,  8565.,  9042.,  9519.,  9996.,  5109.,  5430.,  5751.,  6072.,
      6621.,  6954.,  7287.,  7620.,  9024.,  9528.,  10032., 10536., 9177.,
      9690.,  10203., 10716., 9330.,  9852.,  10374., 10896., 9483.,  10014.,
      10545., 11076., 5649.,  6006.,  6363.,  6720.,  7305.,  7674.,  8043.,
      8412.,  9942.,  10500., 11058., 11616., 10095., 10662., 11229., 11796.,
      10248., 10824., 11400., 11976., 10401., 10986., 11571., 12156., 6189.,
      6582.,  6975.,  7368.,  3430.,  3688.,  3946.,  4204.,  4414.,  4804.,
      5194.,  5584.,  4480.,  4876.,  5272.,  5668.,  4546.,  4948.,  5350.,
      5752.,  4612.,  5020.,  5428.,  5836.,  2542.,  2816.,  3090.,  3364.,
      7726.,  8032.,  8338.,  8644.,  10750., 11212., 11674., 12136., 10888.,
      11356., 11824., 12292., 11026., 11500., 11974., 12448., 11164., 11644.,
      12124., 12604., 6838.,  7160.,  7482.,  7804.,  9357.,  9834.,  10311.,
      10788., 12696., 13416., 14136., 14856., 12849., 13578., 14307., 15036.,
      13002., 13740., 14478., 15216., 13155., 13902., 14649., 15396., 7809.,
      8310.,  8811.,  9312.,  10041., 10554., 11067., 11580., 13614., 14388.,
      15162., 15936., 13767., 14550., 15333., 16116., 13920., 14712., 15504.,
      16296., 14073., 14874., 15675., 16476., 8349.,  8886.,  9423.,  9960.,
      10725., 11274., 11823., 12372., 14532., 15360., 16188., 17016., 14685.,
      15522., 16359., 17196., 14838., 15684., 16530., 17376., 14991., 15846.,
      16701., 17556., 8889.,  9462.,  10035., 10608., 11409., 11994., 12579.,
      13164., 15450., 16332., 17214., 18096., 15603., 16494., 17385., 18276.,
      15756., 16656., 17556., 18456., 15909., 16818., 17727., 18636., 9429.,
      10038., 10647., 11256., 5302.,  5704.,  6106.,  6508.,  6790.,  7396.,
      8002.,  8608.,  6856.,  7468.,  8080.,  8692.,  6922.,  7540.,  8158.,
      8776.,  6988.,  7612.,  8236.,  8860.,  3838.,  4256.,  4674.,  5092.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x6x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1680.,  1752.,  1824.,  1896.,  1833.,  1914.,  1995.,  2076.,  1986.,
      2076.,  2166.,  2256.,  2139.,  2238.,  2337.,  2436.,  2598.,  2724.,
      2850.,  2976.,  2751.,  2886.,  3021.,  3156.,  2904.,  3048.,  3192.,
      3336.,  3057.,  3210.,  3363.,  3516.,  3516.,  3696.,  3876.,  4056.,
      3669.,  3858.,  4047.,  4236.,  3822.,  4020.,  4218.,  4416.,  3975.,
      4182.,  4389.,  4596.,  4434.,  4668.,  4902.,  5136.,  4587.,  4830.,
      5073.,  5316.,  4740.,  4992.,  5244.,  5496.,  4893.,  5154.,  5415.,
      5676.,  7188.,  7584.,  7980.,  8376.,  7341.,  7746.,  8151.,  8556.,
      7494.,  7908.,  8322.,  8736.,  7647.,  8070.,  8493.,  8916.,  8106.,
      8556.,  9006.,  9456.,  8259.,  8718.,  9177.,  9636.,  8412.,  8880.,
      9348.,  9816.,  8565.,  9042.,  9519.,  9996.,  9024.,  9528.,  10032.,
      10536., 9177.,  9690.,  10203., 10716., 9330.,  9852.,  10374., 10896.,
      9483.,  10014., 10545., 11076., 9942.,  10500., 11058., 11616., 10095.,
      10662., 11229., 11796., 10248., 10824., 11400., 11976., 10401., 10986.,
      11571., 12156., 12696., 13416., 14136., 14856., 12849., 13578., 14307.,
      15036., 13002., 13740., 14478., 15216., 13155., 13902., 14649., 15396.,
      13614., 14388., 15162., 15936., 13767., 14550., 15333., 16116., 13920.,
      14712., 15504., 16296., 14073., 14874., 15675., 16476., 14532., 15360.,
      16188., 17016., 14685., 15522., 16359., 17196., 14838., 15684., 16530.,
      17376., 14991., 15846., 16701., 17556., 15450., 16332., 17214., 18096.,
      15603., 16494., 17385., 18276., 15756., 16656., 17556., 18456., 15909.,
      16818., 17727., 18636.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x6x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1072.,  1676.,  1976.,  2276.,  2576.,  1672.,  2418.,  3567.,  3909.,
      4251.,  4593.,  2886.,  3930.,  5619.,  5961.,  6303.,  6645.,  4110.,
      5442.,  7671.,  8013.,  8355.,  8697.,  5334.,  6954.,  9723.,  10065.,
      10407., 10749., 6558.,  3544.,  4736.,  4892.,  5048.,  5204.,  2992.,
      8848.,  12476., 12776., 13076., 13376., 8296.,  11490., 15879., 16221.,
      16563., 16905., 10230., 13002., 17931., 18273., 18615., 18957., 11454.,
      14514., 19983., 20325., 20667., 21009., 12678., 16026., 22035., 22377.,
      22719., 23061., 13902., 7864.,  10352., 10508., 10664., 10820., 6160.,
      16624., 23276., 23576., 23876., 24176., 14920., 20562., 28191., 28533.,
      28875., 29217., 17574., 22074., 30243., 30585., 30927., 31269., 18798.,
      23586., 32295., 32637., 32979., 33321., 20022., 25098., 34347., 34689.,
      35031., 35373., 21246., 12184., 15968., 16124., 16280., 16436., 9328.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x6x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3567.,  3909.,  4251.,  4593.,  5619.,  5961.,  6303.,  6645.,
      7671.,  8013.,  8355.,  8697.,  9723.,  10065., 10407., 10749.,
      15879., 16221., 16563., 16905., 17931., 18273., 18615., 18957.,
      19983., 20325., 20667., 21009., 22035., 22377., 22719., 23061.,
      28191., 28533., 28875., 29217., 30243., 30585., 30927., 31269.,
      32295., 32637., 32979., 33321., 34347., 34689., 35031., 35373.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x6x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2076.,  2144.,  3238.,  3352.,  3814.,  3952.,  4390.,  4552.,  4966.,
      5152.,  3212.,  3344.,  4662.,  4836.,  6855.,  7134.,  7503.,  7818.,
      8151.,  8502.,  8799.,  9186.,  5502.,  5772.,  7542.,  7860.,  10743.,
      11238., 11391., 11922., 12039., 12606., 12687., 13290., 7806.,  8220.,
      10422., 10884., 14631., 15342., 15279., 16026., 15927., 16710., 16575.,
      17394., 10110., 10668., 13302., 13908., 18519., 19446., 19167., 20130.,
      19815., 20814., 20463., 21498., 12414., 13116., 6636.,  7088.,  8782.,
      9472.,  9070.,  9784.,  9358.,  10096., 9646.,  10408., 5468.,  5984.,
      17052., 17696., 23974., 24952., 24550., 25552., 25126., 26152., 25702.,
      26752., 15884., 16592., 21942., 22980., 30183., 31758., 30831., 32442.,
      31479., 33126., 32127., 33810., 19326., 20460., 24822., 26004., 34071.,
      35862., 34719., 36546., 35367., 37230., 36015., 37914., 21630., 22908.,
      27702., 29028., 37959., 39966., 38607., 40650., 39255., 41334., 39903.,
      42018., 23934., 25356., 30582., 32052., 41847., 44070., 42495., 44754.,
      43143., 45438., 43791., 46122., 26238., 27804., 14700., 15728., 19150.,
      20704., 19438., 21016., 19726., 21328., 20014., 21640., 11228., 12320.,
      32028., 33248., 44710., 46552., 45286., 47152., 45862., 47752., 46438.,
      48352., 28556., 29840., 39222., 41124., 53511., 56382., 54159., 57066.,
      54807., 57750., 55455., 58434., 33150., 35148., 42102., 44148., 57399.,
      60486., 58047., 61170., 58695., 61854., 59343., 62538., 35454., 37596.,
      44982., 47172., 61287., 64590., 61935., 65274., 62583., 65958., 63231.,
      66642., 37758., 40044., 47862., 50196., 65175., 68694., 65823., 69378.,
      66471., 70062., 67119., 70746., 40062., 42492., 22764., 24368., 29518.,
      31936., 29806., 32248., 30094., 32560., 30382., 32872., 16988., 18656.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x6x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6855.,  7134.,  7503.,  7818.,  8151.,  8502.,  8799.,  9186.,  10743.,
      11238., 11391., 11922., 12039., 12606., 12687., 13290., 14631., 15342.,
      15279., 16026., 15927., 16710., 16575., 17394., 18519., 19446., 19167.,
      20130., 19815., 20814., 20463., 21498., 30183., 31758., 30831., 32442.,
      31479., 33126., 32127., 33810., 34071., 35862., 34719., 36546., 35367.,
      37230., 36015., 37914., 37959., 39966., 38607., 40650., 39255., 41334.,
      39903., 42018., 41847., 44070., 42495., 44754., 43143., 45438., 43791.,
      46122., 53511., 56382., 54159., 57066., 54807., 57750., 55455., 58434.,
      57399., 60486., 58047., 61170., 58695., 61854., 59343., 62538., 61287.,
      64590., 61935., 65274., 62583., 65958., 63231., 66642., 65175., 68694.,
      65823., 69378., 66471., 70062., 67119., 70746.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x6x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4084.,   4152.,   4220.,   4288.,   6362.,   6476.,   6590.,   6704.,
      7490.,   7628.,   7766.,   7904.,   8618.,   8780.,   8942.,   9104.,
      9746.,   9932.,   10118.,  10304.,  6292.,   6424.,   6556.,   6688.,
      9150.,   9324.,   9498.,   9672.,   13431.,  13710.,  13989.,  14268.,
      14691.,  15006.,  15321.,  15636.,  15951.,  16302.,  16653.,  17004.,
      17211.,  17598.,  17985.,  18372.,  10734.,  11004.,  11274.,  11544.,
      14766.,  15084.,  15402.,  15720.,  20991.,  21486.,  21981.,  22476.,
      22251.,  22782.,  23313.,  23844.,  23511.,  24078.,  24645.,  25212.,
      24771.,  25374.,  25977.,  26580.,  15198.,  15612.,  16026.,  16440.,
      20382.,  20844.,  21306.,  21768.,  28551.,  29262.,  29973.,  30684.,
      29811.,  30558.,  31305.,  32052.,  31071.,  31854.,  32637.,  33420.,
      32331.,  33150.,  33969.,  34788.,  19662.,  20220.,  20778.,  21336.,
      25998.,  26604.,  27210.,  27816.,  36111.,  37038.,  37965.,  38892.,
      37371.,  38334.,  39297.,  40260.,  38631.,  39630.,  40629.,  41628.,
      39891.,  40926.,  41961.,  42996.,  24126.,  24828.,  25530.,  26232.,
      12820.,  13272.,  13724.,  14176.,  16874.,  17564.,  18254.,  18944.,
      17426.,  18140.,  18854.,  19568.,  17978.,  18716.,  19454.,  20192.,
      18530.,  19292.,  20054.,  20816.,  10420.,  10936.,  11452.,  11968.,
      33460.,  34104.,  34748.,  35392.,  46970.,  47948.,  48926.,  49904.,
      48098.,  49100.,  50102.,  51104.,  49226.,  50252.,  51278.,  52304.,
      50354.,  51404.,  52454.,  53504.,  31060.,  31768.,  32476.,  33184.,
      42846.,  43884.,  44922.,  45960.,  58791.,  60366.,  61941.,  63516.,
      60051.,  61662.,  63273.,  64884.,  61311.,  62958.,  64605.,  66252.,
      62571.,  64254.,  65937.,  67620.,  37518.,  38652.,  39786.,  40920.,
      48462.,  49644.,  50826.,  52008.,  66351.,  68142.,  69933.,  71724.,
      67611.,  69438.,  71265.,  73092.,  68871.,  70734.,  72597.,  74460.,
      70131.,  72030.,  73929.,  75828.,  41982.,  43260.,  44538.,  45816.,
      54078.,  55404.,  56730.,  58056.,  73911.,  75918.,  77925.,  79932.,
      75171.,  77214.,  79257.,  81300.,  76431.,  78510.,  80589.,  82668.,
      77691.,  79806.,  81921.,  84036.,  46446.,  47868.,  49290.,  50712.,
      59694.,  61164.,  62634.,  64104.,  81471.,  83694.,  85917.,  88140.,
      82731.,  84990.,  87249.,  89508.,  83991.,  86286.,  88581.,  90876.,
      85251.,  87582.,  89913.,  92244.,  50910.,  52476.,  54042.,  55608.,
      28372.,  29400.,  30428.,  31456.,  36746.,  38300.,  39854.,  41408.,
      37298.,  38876.,  40454.,  42032.,  37850.,  39452.,  41054.,  42656.,
      38402.,  40028.,  41654.,  43280.,  21364.,  22456.,  23548.,  24640.,
      62836.,  64056.,  65276.,  66496.,  87578.,  89420.,  91262.,  93104.,
      88706.,  90572.,  92438.,  94304.,  89834.,  91724.,  93614.,  95504.,
      90962.,  92876.,  94790.,  96704.,  55828.,  57112.,  58396.,  59680.,
      76542.,  78444.,  80346.,  82248.,  104151., 107022., 109893., 112764.,
      105411., 108318., 111225., 114132., 106671., 109614., 112557., 115500.,
      107931., 110910., 113889., 116868., 64302.,  66300.,  68298.,  70296.,
      82158.,  84204.,  86250.,  88296.,  111711., 114798., 117885., 120972.,
      112971., 116094., 119217., 122340., 114231., 117390., 120549., 123708.,
      115491., 118686., 121881., 125076., 68766.,  70908.,  73050.,  75192.,
      87774.,  89964.,  92154.,  94344.,  119271., 122574., 125877., 129180.,
      120531., 123870., 127209., 130548., 121791., 125166., 128541., 131916.,
      123051., 126462., 129873., 133284., 73230.,  75516.,  77802.,  80088.,
      93390.,  95724.,  98058.,  100392., 126831., 130350., 133869., 137388.,
      128091., 131646., 135201., 138756., 129351., 132942., 136533., 140124.,
      130611., 134238., 137865., 141492., 77694.,  80124.,  82554.,  84984.,
      43924.,  45528.,  47132.,  48736.,  56618.,  59036.,  61454.,  63872.,
      57170.,  59612.,  62054.,  64496.,  57722.,  60188.,  62654.,  65120.,
      58274.,  60764.,  63254.,  65744.,  32308.,  33976.,  35644.,  37312.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x6x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      13431.,  13710.,  13989.,  14268.,  14691.,  15006.,  15321.,  15636.,
      15951.,  16302.,  16653.,  17004.,  17211.,  17598.,  17985.,  18372.,
      20991.,  21486.,  21981.,  22476.,  22251.,  22782.,  23313.,  23844.,
      23511.,  24078.,  24645.,  25212.,  24771.,  25374.,  25977.,  26580.,
      28551.,  29262.,  29973.,  30684.,  29811.,  30558.,  31305.,  32052.,
      31071.,  31854.,  32637.,  33420.,  32331.,  33150.,  33969.,  34788.,
      36111.,  37038.,  37965.,  38892.,  37371.,  38334.,  39297.,  40260.,
      38631.,  39630.,  40629.,  41628.,  39891.,  40926.,  41961.,  42996.,
      58791.,  60366.,  61941.,  63516.,  60051.,  61662.,  63273.,  64884.,
      61311.,  62958.,  64605.,  66252.,  62571.,  64254.,  65937.,  67620.,
      66351.,  68142.,  69933.,  71724.,  67611.,  69438.,  71265.,  73092.,
      68871.,  70734.,  72597.,  74460.,  70131.,  72030.,  73929.,  75828.,
      73911.,  75918.,  77925.,  79932.,  75171.,  77214.,  79257.,  81300.,
      76431.,  78510.,  80589.,  82668.,  77691.,  79806.,  81921.,  84036.,
      81471.,  83694.,  85917.,  88140.,  82731.,  84990.,  87249.,  89508.,
      83991.,  86286.,  88581.,  90876.,  85251.,  87582.,  89913.,  92244.,
      104151., 107022., 109893., 112764., 105411., 108318., 111225., 114132.,
      106671., 109614., 112557., 115500., 107931., 110910., 113889., 116868.,
      111711., 114798., 117885., 120972., 112971., 116094., 119217., 122340.,
      114231., 117390., 120549., 123708., 115491., 118686., 121881., 125076.,
      119271., 122574., 125877., 129180., 120531., 123870., 127209., 130548.,
      121791., 125166., 128541., 131916., 123051., 126462., 129873., 133284.,
      126831., 130350., 133869., 137388., 128091., 131646., 135201., 138756.,
      129351., 132942., 136533., 140124., 130611., 134238., 137865., 141492.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x6x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8232.,   12892.,  15244.,  17596.,  19948.,  12936.,  18756.,  27654.,
      30318.,  32982.,  35646.,  22356.,  30564.,  43638.,  46302.,  48966.,
      51630.,  31860.,  42372.,  59622.,  62286.,  64950.,  67614.,  41364.,
      54180.,  75606.,  78270.,  80934.,  83598.,  50868.,  27336.,  36364.,
      37564.,  38764.,  39964.,  22824.,  69288.,  97564.,  99916.,  102268.,
      104620., 64776.,  89604.,  123558., 126222., 128886., 131550., 79380.,
      101412., 139542., 142206., 144870., 147534., 88884.,  113220., 155526.,
      158190., 160854., 163518., 98388.,  125028., 171510., 174174., 176838.,
      179502., 107892., 60744.,  79564.,  80764.,  81964.,  83164.,  47016.,
      130344., 182236., 184588., 186940., 189292., 116616., 160452., 219462.,
      222126., 224790., 227454., 136404., 172260., 235446., 238110., 240774.,
      243438., 145908., 184068., 251430., 254094., 256758., 259422., 155412.,
      195876., 267414., 270078., 272742., 275406., 164916., 94152.,  122764.,
      123964., 125164., 126364., 71208.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x6x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      27654.,  30318.,  32982.,  35646.,  43638.,  46302.,  48966.,  51630.,
      59622.,  62286.,  64950.,  67614.,  75606.,  78270.,  80934.,  83598.,
      123558., 126222., 128886., 131550., 139542., 142206., 144870., 147534.,
      155526., 158190., 160854., 163518., 171510., 174174., 176838., 179502.,
      219462., 222126., 224790., 227454., 235446., 238110., 240774., 243438.,
      251430., 254094., 256758., 259422., 267414., 270078., 272742., 275406.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x6x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      16200.,  16464.,  25340.,  25784.,  29948.,  30488.,  34556.,  35192.,
      39164.,  39896.,  25352.,  25872.,  36828.,  37512.,  54210.,  55308.,
      59394.,  60636.,  64578.,  65964.,  69762.,  71292.,  43644.,  44712.,
      59868.,  61128.,  85314.,  87276.,  90498.,  92604.,  95682.,  97932.,
      100866., 103260., 62076.,  63720.,  82908.,  84744.,  116418., 119244.,
      121602., 124572., 126786., 129900., 131970., 135228., 80508.,  82728.,
      105948., 108360., 147522., 151212., 152706., 156540., 157890., 161868.,
      163074., 167196., 98940.,  101736., 52872.,  54672.,  69980.,  72728.,
      72284.,  75128.,  74588.,  77528.,  76892.,  79928.,  43592.,  45648.,
      136008., 138576., 191228., 195128., 195836., 199832., 200444., 204536.,
      205052., 209240., 126728., 129552., 175068., 179208., 240834., 247116.,
      246018., 252444., 251202., 257772., 256386., 263100., 154236., 158760.,
      198108., 202824., 271938., 279084., 277122., 284412., 282306., 289740.,
      287490., 295068., 172668., 177768., 221148., 226440., 303042., 311052.,
      308226., 316380., 313410., 321708., 318594., 327036., 191100., 196776.,
      244188., 250056., 334146., 343020., 339330., 348348., 344514., 353676.,
      349698., 359004., 209532., 215784., 117384., 121488., 152924., 159128.,
      155228., 161528., 157532., 163928., 159836., 166328., 89672.,  94032.,
      255816., 260688., 357116., 364472., 361724., 369176., 366332., 373880.,
      370940., 378584., 228104., 233232., 313308., 320904., 427458., 438924.,
      432642., 444252., 437826., 449580., 443010., 454908., 264828., 272808.,
      336348., 344520., 458562., 470892., 463746., 476220., 468930., 481548.,
      474114., 486876., 283260., 291816., 359388., 368136., 489666., 502860.,
      494850., 508188., 500034., 513516., 505218., 518844., 301692., 310824.,
      382428., 391752., 520770., 534828., 525954., 540156., 531138., 545484.,
      536322., 550812., 320124., 329832., 181896., 188304., 235868., 245528.,
      238172., 247928., 240476., 250328., 242780., 252728., 135752., 142416.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x6x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      54210.,  55308.,  59394.,  60636.,  64578.,  65964.,  69762.,  71292.,
      85314.,  87276.,  90498.,  92604.,  95682.,  97932.,  100866., 103260.,
      116418., 119244., 121602., 124572., 126786., 129900., 131970., 135228.,
      147522., 151212., 152706., 156540., 157890., 161868., 163074., 167196.,
      240834., 247116., 246018., 252444., 251202., 257772., 256386., 263100.,
      271938., 279084., 277122., 284412., 282306., 289740., 287490., 295068.,
      303042., 311052., 308226., 316380., 313410., 321708., 318594., 327036.,
      334146., 343020., 339330., 348348., 344514., 353676., 349698., 359004.,
      427458., 438924., 432642., 444252., 437826., 449580., 443010., 454908.,
      458562., 470892., 463746., 476220., 468930., 481548., 474114., 486876.,
      489666., 502860., 494850., 508188., 500034., 513516., 505218., 518844.,
      520770., 534828., 525954., 540156., 531138., 545484., 536322., 550812.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, SAME3x6x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      32136.,   32400.,   32664.,   32928.,   50236.,   50680.,   51124.,
      51568.,   59356.,   59896.,   60436.,   60976.,   68476.,   69112.,
      69748.,   70384.,   77596.,   78328.,   79060.,   79792.,   50184.,
      50704.,   51224.,   51744.,   72972.,   73656.,   74340.,   75024.,
      107322.,  108420.,  109518.,  110616.,  117546.,  118788.,  120030.,
      121272.,  127770.,  129156.,  130542.,  131928.,  137994.,  139524.,
      141054.,  142584.,  86220.,   87288.,   88356.,   89424.,   118476.,
      119736.,  120996.,  122256.,  168666.,  170628.,  172590.,  174552.,
      178890.,  180996.,  183102.,  185208.,  189114.,  191364.,  193614.,
      195864.,  199338.,  201732.,  204126.,  206520.,  122508.,  124152.,
      125796.,  127440.,  163980.,  165816.,  167652.,  169488.,  230010.,
      232836.,  235662.,  238488.,  240234.,  243204.,  246174.,  249144.,
      250458.,  253572.,  256686.,  259800.,  260682.,  263940.,  267198.,
      270456.,  158796.,  161016.,  163236.,  165456.,  209484.,  211896.,
      214308.,  216720.,  291354.,  295044.,  298734.,  302424.,  301578.,
      305412.,  309246.,  313080.,  311802.,  315780.,  319758.,  323736.,
      322026.,  326148.,  330270.,  334392.,  195084.,  197880.,  200676.,
      203472.,  103944.,  105744.,  107544.,  109344.,  137212.,  139960.,
      142708.,  145456.,  141724.,  144568.,  147412.,  150256.,  146236.,
      149176.,  152116.,  155056.,  150748.,  153784.,  156820.,  159856.,
      85128.,   87184.,   89240.,   91296.,   269448.,  272016.,  274584.,
      277152.,  378556.,  382456.,  386356.,  390256.,  387676.,  391672.,
      395668.,  399664.,  396796.,  400888.,  404980.,  409072.,  405916.,
      410104.,  414292.,  418480.,  250632.,  253456.,  256280.,  259104.,
      345996.,  350136.,  354276.,  358416.,  475386.,  481668.,  487950.,
      494232.,  485610.,  492036.,  498462.,  504888.,  495834.,  502404.,
      508974.,  515544.,  506058.,  512772.,  519486.,  526200.,  303948.,
      308472.,  312996.,  317520.,  391500.,  396216.,  400932.,  405648.,
      536730.,  543876.,  551022.,  558168.,  546954.,  554244.,  561534.,
      568824.,  557178.,  564612.,  572046.,  579480.,  567402.,  574980.,
      582558.,  590136.,  340236.,  345336.,  350436.,  355536.,  437004.,
      442296.,  447588.,  452880.,  598074.,  606084.,  614094.,  622104.,
      608298.,  616452.,  624606.,  632760.,  618522.,  626820.,  635118.,
      643416.,  628746.,  637188.,  645630.,  654072.,  376524.,  382200.,
      387876.,  393552.,  482508.,  488376.,  494244.,  500112.,  659418.,
      668292.,  677166.,  686040.,  669642.,  678660.,  687678.,  696696.,
      679866.,  689028.,  698190.,  707352.,  690090.,  699396.,  708702.,
      718008.,  412812.,  419064.,  425316.,  431568.,  230664.,  234768.,
      238872.,  242976.,  299644.,  305848.,  312052.,  318256.,  304156.,
      310456.,  316756.,  323056.,  308668.,  315064.,  321460.,  327856.,
      313180.,  319672.,  326164.,  332656.,  174984.,  179344.,  183704.,
      188064.,  506760.,  511632.,  516504.,  521376.,  706876.,  714232.,
      721588.,  728944.,  715996.,  723448.,  730900.,  738352.,  725116.,
      732664.,  740212.,  747760.,  734236.,  741880.,  749524.,  757168.,
      451080.,  456208.,  461336.,  466464.,  619020.,  626616.,  634212.,
      641808.,  843450.,  854916.,  866382.,  877848.,  853674.,  865284.,
      876894.,  888504.,  863898.,  875652.,  887406.,  899160.,  874122.,
      886020.,  897918.,  909816.,  521676.,  529656.,  537636.,  545616.,
      664524.,  672696.,  680868.,  689040.,  904794.,  917124.,  929454.,
      941784.,  915018.,  927492.,  939966.,  952440.,  925242.,  937860.,
      950478.,  963096.,  935466.,  948228.,  960990.,  973752.,  557964.,
      566520.,  575076.,  583632.,  710028.,  718776.,  727524.,  736272.,
      966138.,  979332.,  992526.,  1005720., 976362.,  989700.,  1003038.,
      1016376., 986586.,  1000068., 1013550., 1027032., 996810.,  1010436.,
      1024062., 1037688., 594252.,  603384.,  612516.,  621648.,  755532.,
      764856.,  774180.,  783504.,  1027482., 1041540., 1055598., 1069656.,
      1037706., 1051908., 1066110., 1080312., 1047930., 1062276., 1076622.,
      1090968., 1058154., 1072644., 1087134., 1101624., 630540.,  640248.,
      649956.,  659664.,  357384.,  363792.,  370200.,  376608.,  462076.,
      471736.,  481396.,  491056.,  466588.,  476344.,  486100.,  495856.,
      471100.,  480952.,  490804.,  500656.,  475612.,  485560.,  495508.,
      505456.,  264840.,  271504.,  278168.,  284832.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow3Stride1, VALID3x6x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      107322.,  108420.,  109518.,  110616.,  117546.,  118788.,  120030.,
      121272.,  127770.,  129156.,  130542.,  131928.,  137994.,  139524.,
      141054.,  142584.,  168666.,  170628.,  172590.,  174552.,  178890.,
      180996.,  183102.,  185208.,  189114.,  191364.,  193614.,  195864.,
      199338.,  201732.,  204126.,  206520.,  230010.,  232836.,  235662.,
      238488.,  240234.,  243204.,  246174.,  249144.,  250458.,  253572.,
      256686.,  259800.,  260682.,  263940.,  267198.,  270456.,  291354.,
      295044.,  298734.,  302424.,  301578.,  305412.,  309246.,  313080.,
      311802.,  315780.,  319758.,  323736.,  322026.,  326148.,  330270.,
      334392.,  475386.,  481668.,  487950.,  494232.,  485610.,  492036.,
      498462.,  504888.,  495834.,  502404.,  508974.,  515544.,  506058.,
      512772.,  519486.,  526200.,  536730.,  543876.,  551022.,  558168.,
      546954.,  554244.,  561534.,  568824.,  557178.,  564612.,  572046.,
      579480.,  567402.,  574980.,  582558.,  590136.,  598074.,  606084.,
      614094.,  622104.,  608298.,  616452.,  624606.,  632760.,  618522.,
      626820.,  635118.,  643416.,  628746.,  637188.,  645630.,  654072.,
      659418.,  668292.,  677166.,  686040.,  669642.,  678660.,  687678.,
      696696.,  679866.,  689028.,  698190.,  707352.,  690090.,  699396.,
      708702.,  718008.,  843450.,  854916.,  866382.,  877848.,  853674.,
      865284.,  876894.,  888504.,  863898.,  875652.,  887406.,  899160.,
      874122.,  886020.,  897918.,  909816.,  904794.,  917124.,  929454.,
      941784.,  915018.,  927492.,  939966.,  952440.,  925242.,  937860.,
      950478.,  963096.,  935466.,  948228.,  960990.,  973752.,  966138.,
      979332.,  992526.,  1005720., 976362.,  989700.,  1003038., 1016376.,
      986586.,  1000068., 1013550., 1027032., 996810.,  1010436., 1024062.,
      1037688., 1027482., 1041540., 1055598., 1069656., 1037706., 1051908.,
      1066110., 1080312., 1047930., 1062276., 1076622., 1090968., 1058154.,
      1072644., 1087134., 1101624.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}